feat: Add validation using JSON Schema

Author: prantlf

README.md

@@ -10,6 +10,7 @@
 This is a fork of the original package with the following enhancements:
 
 * Validates with both [JSON] and [JSON5] standards.
+* Supports [JSON Schema] drafts 04, 06 and 07.
 * Optionally recognizes JavaScript-style comments and single quoted strings.
 * Optionally ignores trailing commas and reports duplicate object keys as an error.
 * Prefers using the 8x faster native JSON parser, if possible.
@@ -78,6 +79,21 @@ Options can be passed as keys in an object to the `jsonlint` function. The follo
 * `indent`, the value passed to `JSON.stringify`, it can be the number of spaces, or string like "\t"
 * `sortKeys`, when `true` keys of objects in the output JSON will be sorted alphabetically (`format` has to be set to `true` too)
 
+#### Schema Validation
+
+You can validate JSON files using JSON Schema drafts 04, 06 or 07, if you specify the schema in addition to other options:
+
+    jsonlint({
+      schema: {
+        src: 'some/manifest-schema.json',
+        environment: 'json-schema-draft-04'
+      }
+    })
+
+* `schema`, when set the source file will be validated using ae JSON Schema in addition to the syntax checks
+* `src`, when filled with a file path, the file will be used as a source of the JSON Schema
+* `environment`, can specify the version of the JSON Schema draft to use for validation: "json-schema-draft-04", "json-schema-draft-06" or "json-schema-draft-07" (if not set, the schema draft version will be inferred automatically)
+
 ### jsonlint.reporter(customReporter)
 
 #### customReporter(file)
@@ -121,3 +137,4 @@ Licensed under the [MIT License].
 [`jsonlint`]: https://prantlf.github.io/jsonlint/
 [JSON]: https://tools.ietf.org/html/rfc8259
 [JSON5]: https://spec.json5.org
+[JSON Schema]: https://json-schema.org

index.js

@@ -1,62 +1,107 @@
 'use strict';
 
+var fs = require('fs');
 var mapStream = require('map-stream');
 var colors = require('ansi-colors');
 var jsonlint = require('@prantlf/jsonlint');
+var validator = require('@prantlf/jsonlint/lib/validator');
 var sorter = require('@prantlf/jsonlint/lib/sorter');
 var through = require('through2');
 var PluginError = require('plugin-error');
 var log = require('fancy-log');
 
-var formatOutput = function (msg) {
-    var output = {};
-
-    if (msg) { output.message = msg; }
-
-    output.success = msg ? false : true;
-
-    return output;
-};
-
 var jsonLintPlugin = function (options) {
     options = Object.assign({
         mode: 'json',
         ignoreComments: false,
         ignoreTrailingCommas: false,
         allowSingleQuotedStrings: false,
         allowDuplicateObjectKeys: true,
+        schema: {},
         format: false,
         indent: 2,
         sortKeys: false
     }, options);
+    var schema = options.schema;
+    var parserOptions = {
+        mode: options.mode,
+        ignoreComments: options.ignoreComments || options.cjson ||
+                        options.mode === 'cjson' || options.mode === 'json5',
+        ignoreTrailingCommas: options.ignoreTrailingCommas || options.mode === 'json5',
+        allowSingleQuotedStrings: options.allowSingleQuotedStrings || options.mode === 'json5',
+        allowDuplicateObjectKeys: options.allowDuplicateObjectKeys,
+        environment: schema.environment
+    };
+    var schemaContent;
+
+    function createResult (message) {
+        var result = {};
+        if (message) {
+            result.message = message;
+            result.success = false;
+        } else {
+            result.success = true;
+        }
+        return result;
+    }
+
+    function formatOutput (parsedData, file) {
+        if (options.format) {
+            if (options.sortKeys) {
+              parsedData = sorter.sortObject(parsedData);
+            }
+            var formatted = JSON.stringify(parsedData, null, options.indent) + '\n';
+            file.contents = new Buffer(formatted);
+        }
+    }
+
+    function validateSchema (parsedData, file, finish) {
+        var errorMessage;
+        try {
+            var validate = validator.compile(schemaContent, parserOptions);
+            validate(parsedData);
+            formatOutput(parsedData, file);
+        }
+        catch (error) {
+            errorMessage = error.message;
+        }
+        finish(errorMessage);
+    }
+
+    function loadAndValidateSchema (parsedData, file, finish) {
+        if (schemaContent) {
+            validateSchema(parsedData, finish);
+        } else {
+            fs.readFile(schema.src, 'utf-8', function(error, fileContent) {
+                if (error) {
+                    finish(error.message);
+                } else {
+                    schemaContent = fileContent;
+                    validateSchema(parsedData, file, finish);
+                }
+            });
+        }
+    }
 
     return mapStream(function (file, cb) {
-        var errorMessage = '';
-
-        var parserOptions = {
-            mode: options.mode,
-            ignoreComments: options.ignoreComments || options.cjson ||
-                            options.mode === 'cjson' || options.mode === 'json5',
-            ignoreTrailingCommas: options.ignoreTrailingCommas || options.mode === 'json5',
-            allowSingleQuotedStrings: options.allowSingleQuotedStrings || options.mode === 'json5',
-            allowDuplicateObjectKeys: options.allowDuplicateObjectKeys
-        };
+        var errorMessage;
+        function finish (errorMessage) {
+            file.jsonlint = createResult(errorMessage);
+            cb(null, file);
+        }
+
         try {
             var parsedData = jsonlint.parse(String(file.contents), parserOptions);
-            if (options.format) {
-                if (options.sortKeys) {
-                  parsedData = sorter.sortObject(parsedData);
-                }
-                var formatted = JSON.stringify(parsedData, null, options.indent) + '\n';
-                file.contents = new Buffer(formatted);
+            if (schema.src) {
+                loadAndValidateSchema(parsedData, file, finish);
+                return;
             }
+            formatOutput(parsedData, file);
         }
-        catch (err) {
-            errorMessage = err.message;
+        catch (error) {
+            errorMessage = error.message;
         }
-        file.jsonlint = formatOutput(errorMessage);
-
-        cb(null, file);
+        finish(errorMessage);
     });
 };
 

test/fixtures/data.json

@@ -0,0 +1,3 @@
+{
+    "key": "value"
+}

test/fixtures/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "title": "Schema for data.json",
+  "properties": {
+    "key": {
+      "type": "string",
+      "title": "Required property"
+    }
+  },
+  "required": [
+    "key"
+  ]
+}

test/main.js

@@ -188,6 +188,34 @@ describe('gulp-jsonlint', function () {
         });
     });
 
+    it('succeeds validation using JSON Schema', function (done) {
+        parseValidFile('fixtures/data.json', done, {
+            schema: {
+                src: 'test/fixtures/schema.json'
+            }
+        });
+    });
+
+    it('fails validation using JSON Schema', function (done) {
+        var file = getFile('fixtures/valid.json');
+        var stream = jsonLintPlugin({
+            schema: {
+                src: 'test/fixtures/schema.json'
+            }
+        });
+
+        stream.on('data', function (f) {
+            should.exist(f.jsonlint.success);
+            f.jsonlint.success.should.equal(false);
+            should.exist(f.jsonlint.message);
+            f.jsonlint.message.should.match(/should have required property/);
+        });
+
+        stream.once('end', done);
+        stream.write(file);
+        stream.end();
+    });
+
     it('can format the output', function (done) {
         formatValidFile('fixtures/json5.json', done, {
             mode: 'json5',