feat: Improve schema error reporting to the level of data parsing

* Include location and data exzerpt.
* Use data JSON pointer and append schema JSON pointer too.
* Remort errors from schema parsing in the same quality too.

Author: prantlf

README.md

@@ -17,10 +17,11 @@ This is a fork of the original package with the following enhancements:
 * Optionally recognizes JavaScript-style comments and single quoted strings.
 * Optionally ignores trailing commas and reports duplicate object keys as an error.
 * Supports [JSON Schema] drafts 04, 06 and 07.
-* Prefers the native JSON parser to gain the [best performance], while showing error messages of the same quality.
+* Prefers the native JSON parser if possible to run [7x faster than the custom parser].
+* Reports errors with rich additional information. From the schema validation too.
 * Implements JavaScript modules using [UMD] to work everywhere.
 * Depends on up-to-date npm modules with no installation warnings.
-* Small size - 17.6 kB minified, 6.1 kB gzipped.
+* Small size - 19.4 kB minified, 6.7 kB gzipped.
 
 Integration to the favourite task loaders is provided by the following NPM modules:
 
@@ -121,6 +122,8 @@ const data3 = parse("{'creative': true /* for creativity */}", {
 })
 ```
 
+Have a look at the [source] of the [on-line page] to see how to use `jsonlint` on web page.
+
 The exported `parse` method is compatible with the native `JSON.parse` method. The second parameter provides the additional functionality:
 
     parse(input, [reviver|options])
@@ -151,17 +154,16 @@ The `mode` parameter (string) sets parsing options to match a common format of i
 
 ### Schema Validation
 
-The parsing method returns the parsed object or throws an error. If the parsing succeeds, you can validate the input against a JSON schema using the `lib/validator` module:
+You can validate the input against a JSON schema using the `lib/validator` module. The `validate` method accepts either an earlier parsed JSON data or a string with the JSON input:
 
 ```js
-const { parse } = require('@prantlf/jsonlint')
 const { compile } = require('@prantlf/jsonlint/lib/validator')
 const validate = compile('string with JSON schema')
 // Throws an error in case of failure.
-validate(parse('string with JSON data'))
+const parsed = validate('string with JSON data')
 ```
 
-Compiling JSON schema supports the same options as parsing JSON data (except for `reviver`). They can be passed as the second (object) parameter. The optional second `environment` parameter can be passed either as a string or as an additional property in the options object too:
+If a string is passed to the `validate` method, the same options as for parsing JSON data can be passed as the second parameter. Compiling JSON schema supports the same options as parsing JSON data too (except for `reviver`). They can be passed as the second (object) parameter. The optional second `environment` parameter can be passed either as a string or as an additional property in the options object too:
 
 ```js
 const validate = compile('string with JSON schema', {
@@ -173,11 +175,13 @@ const validate = compile('string with JSON schema', {
 
 This is a part of an output from the [parser benchmark], when parsing a 4.2 KB formatted string ([package.json](./package.json)) with Node.js 10.15.3:
 
-    the built-in parser x 61,588 ops/sec ±0.75% (80 runs sampled)
-    the pure jju parser x 11,396 ops/sec ±1.05% (86 runs sampled)
-    the extended jju parser x 8,221 ops/sec ±0.99% (87 runs sampled)
+    the built-in parser x 68,212 ops/sec ±0.86% (87 runs sampled)
+    the pure jju parser x 10,234 ops/sec ±1.08% (89 runs sampled)
+    the extended jju parser x 10,210 ops/sec ±1.26% (88 runs sampled)
+    the tokenisable jju parser x 8,832 ops/sec ±0.92% (89 runs sampled)
+    the tokenising jju parser x 7,911 ops/sec ±1.05% (86 runs sampled)
 
-A custom JSON parser is [a lot slower] than the built-in one. However, it is more important to have a [clear error reporting] than the highest speed in scenarios like parsing configuration files. Extending the parser with the support for comments and single-quoted strings does not affect significantly the performance.
+A custom JSON parser is [a lot slower] than the built-in one. However, it is more important to have a [clear error reporting] than the highest speed in scenarios like parsing configuration files. Extending the parser with the support for comments and single-quoted strings does not affect the performance. Making the parser collect tokens and their locations decreases the performance a bit.
 
 ### Error Handling
 
@@ -237,3 +241,5 @@ Licensed under the MIT license.
 [parser benchmark]: ./benchmarks#json-parser-comparison
 [a lot slower]: ./benchmarks/results/performance.md#results
 [clear error reporting]: ./benchmarks/results/errorReportingQuality.md#results
+[on-line page]: http://prantlf.github.com/jsonlint/
+[source]: ./web/jsonhint.html

lib/cli.js

@@ -60,10 +60,6 @@ function parse (source, file) {
       allowSingleQuotedStrings: options.singleQuotedStrings,
       allowDuplicateObjectKeys: options.duplicateKeys
     }
-    parsed = parser.parse(source, parserOptions)
-    if (options.sortKeys) {
-      parsed = sorter.sortObject(parsed)
-    }
     if (options.validate) {
       var validate
       try {
@@ -75,7 +71,12 @@ function parse (source, file) {
           options.validate + '".\n' + error.message
         throw new Error(message)
       }
-      validate(parsed)
+      parsed = validate(source, parserOptions)
+    } else {
+      parsed = parser.parse(source, parserOptions)
+    }
+    if (options.sortKeys) {
+      parsed = sorter.sortObject(parsed)
     }
     return JSON.stringify(parsed, null, options.indent)
   } catch (e) {

lib/validator.js

@@ -28,48 +28,145 @@
 }(this, function (exports, Ajv, jsonlint, requireSchemaDraft) {
   'use strict'
 
-  function compile (schema, environment) {
-    var options = {}
-    if (typeof environment === 'object' && !(environment instanceof String)) {
-      options = environment
-      environment = options.environment
+  function addErrorLocation (problem, input, tokens, dataPath) {
+    var token = tokens.find(function (token) {
+      return dataPath === jsonlint.pathToPointer(token.path)
+    })
+    if (token) {
+      var location = token.location.start
+      var offset = location.offset
+      var line = location.line
+      var column = location.column
+      var texts = jsonlint.getErrorTexts(problem.reason, input, offset, line, column)
+      problem.message = texts.message
+      problem.exzerpt = texts.exzerpt
+      if (texts.pointer) {
+        problem.pointer = texts.pointer
+        problem.location = {
+          start: {
+            column: column,
+            line: line,
+            offset: offset
+          }
+        }
+      }
+      return true
+    }
+  }
+
+  function errorToProblem (error, input, tokens) {
+    var dataPath = error.dataPath
+    var schemaPath = error.schemaPath
+    var reason = (dataPath || '/') + ' ' + error.message + '; see ' + schemaPath
+    var problem = {
+      reason: reason,
+      dataPath: dataPath,
+      schemaPath: schemaPath
+    }
+    if (!addErrorLocation(problem, input, tokens, dataPath)) {
+      problem.message = reason
+    }
+    return problem
+  }
+
+  function createError (errors, data, input, options) {
+    if (!input) {
+      input = JSON.stringify(data, undefined, 2)
     }
+    if (!options) {
+      options = {}
+    }
+    Object.assign(options, {
+      tokenLocations: true,
+      tokenPaths: true
+    })
+    var tokens = jsonlint.tokenize(input, options)
+    // var problems = errors.map(function (error) {
+    //   return errorToProblem(error, input, tokens)
+    // })
+    // var message = problems
+    //   .map(function (problem) {
+    //     return problem.message
+    //   })
+    //   .join('\n')
+    var problem = errorToProblem(errors[0], input, tokens)
+    var error = new SyntaxError(problem.message)
+    Object.assign(error, problem)
+    return error
+  }
+
+  function createAjv (environment) {
+    var ajvOptions = { jsonPointers: true }
     var ajv
     if (!environment) {
-      ajv = new Ajv({ schemaId: 'auto' })
+      ajvOptions.schemaId = 'auto'
+      ajv = new Ajv(ajvOptions)
       ajv.addMetaSchema(requireSchemaDraft('json-schema-draft-04'))
       ajv.addMetaSchema(requireSchemaDraft('json-schema-draft-06'))
     } else if (environment === 'json-schema-draft-07') {
-      ajv = new Ajv()
+      ajv = new Ajv(ajvOptions)
     } else if (environment === 'json-schema-draft-06') {
-      ajv = new Ajv()
+      ajv = new Ajv(ajvOptions)
       ajv.addMetaSchema(requireSchemaDraft('json-schema-draft-06'))
     } else if (environment === 'json-schema-draft-04') {
-      ajv = new Ajv({ schemaId: 'id' })
+      ajvOptions.schemaId = 'id'
+      ajv = new Ajv(ajvOptions)
       ajv.addMetaSchema(requireSchemaDraft('json-schema-draft-04'))
     } else {
-      throw new Error('Unsupported environment for the JSON schema validation: "' +
+      throw new RangeError('Unsupported environment for the JSON schema validation: "' +
         environment + '".')
     }
-    var validate
+    return ajv
+  }
+
+  function compileSchema (ajv, schema, parseOptions) {
+    var parsed
     try {
-      schema = jsonlint.parse(schema, {
-        mode: options.mode,
-        ignoreComments: options.ignoreComments,
-        ignoreTrailingCommas: options.ignoreTrailingCommas,
-        allowSingleQuotedStrings: options.allowSingleQuotedStrings,
-        allowDuplicateObjectKeys: options.allowDuplicateObjectKeys
-      })
-      validate = ajv.compile(schema)
+      parsed = jsonlint.parse(schema, parseOptions)
     } catch (error) {
-      throw new Error('Compiling the JSON schema failed.\n' + error.message)
+      error.message = 'Parsing the JSON schema failed.\n' + error.message
+      throw error
+    }
+    try {
+      return ajv.compile(parsed)
+    } catch (originalError) {
+      var errors = ajv.errors
+      var betterError = errors
+        ? createError(errors, parsed, schema, parseOptions)
+        : originalError
+      betterError.message = 'Compiling the JSON schema failed.\n' + betterError.message
+      throw betterError
+    }
+  }
+
+  function compile (schema, environment) {
+    var options = {}
+    if (typeof environment === 'object' && !(environment instanceof String)) {
+      options = environment
+      environment = options.environment
     }
-    return function (data) {
-      var result = validate(data)
-      if (!result) {
-        var message = ajv.errorsText(validate.errors)
-        throw new Error(message)
+    var ajv = createAjv(environment)
+    var parseOptions = {
+      mode: options.mode,
+      ignoreComments: options.ignoreComments,
+      ignoreTrailingCommas: options.ignoreTrailingCommas,
+      allowSingleQuotedStrings: options.allowSingleQuotedStrings,
+      allowDuplicateObjectKeys: options.allowDuplicateObjectKeys
+    }
+    var validate = compileSchema(ajv, schema, parseOptions)
+    return function (data, input, options) {
+      if (typeof data === 'string' || data instanceof String) {
+        options = input
+        input = data
+        data = jsonlint.parse(input, options)
+      } else if (!(typeof input === 'string' || input instanceof String)) {
+        options = input
+        input = undefined
+      }
+      if (validate(data)) {
+        return data
       }
+      throw createError(validate.errors, data, input, options)
     }
   }
 

web/jsonlint.html

@@ -198,11 +198,14 @@ <h2>Result</h2>
                                       mode === 'json5',
             allowDuplicateObjectKeys: document.getElementById('duplicate-object-keys').checked,
           }
-          var parsed = jsonlint.parse(document.getElementById('data').value, parserOptions)
+          var source = document.getElementById('data').value
+          var parsed
           if (document.getElementById('with-schema').checked) {
             var schema = document.getElementById('schema').value
             var validate = jsonlintValidator.compile(schema, parserOptions)
-            validate(parsed)
+            parsed = validate(source, parserOptions)
+          } else {
+            parsed = jsonlint.parse(source, parserOptions)
           }
           document.getElementById('result').innerText = 'Data is valid!'
           document.getElementById('result').className = 'pass'