z-schema 6.0.2 → 7.0.0-beta.1

package/bin/z-schema

@@ -3,45 +3,52 @@
 // set default exitCode for node 0.10
 process.exitCode = 0;
 
-var fs      = require("fs");
-var path    = require("path");
-var program = require("commander");
-var request = require("https").request;
-var package = require("./../package.json");
-var ZSchema = require("./../src/ZSchema");
+import fs from 'fs';
+import path from 'path';
+import { program } from 'commander';
+import { request } from 'https';
+import pkg from '../package.json' with { type: 'json' };
+import ZSchema from '../dist/ZSchema.js';
 
 program
-  .version(package.version)
-  .usage("[options] <schema> <json1?> <json2?> <json3?>")
-  .option("--asyncTimeout <n>", "default timeout for all async tasks", parseInt)
-  .option("--forceAdditional", "force additionalProperties and additionalItems to be defined on \"object\" and \"array\" types")
-  .option("--assumeAdditional", "assume additionalProperties and additionalItems are defined as \"false\" where appropriate")
-  .option("--forceItems", "force items to be defined on \"array\" types")
-  .option("--forceMinItems", "force minItems to be defined on \"array\" types")
-  .option("--forceMaxItems", "force maxItems to be defined on \"array\" types")
-  .option("--forceMinLength", "force minLength to be defined on \"string\" types")
-  .option("--forceMaxLength", "force maxLength to be defined on \"string\" types")  
-  .option("--forceProperties", "force properties or patternProperties to be defined on \"object\" types")
-  .option("--ignoreUnresolvableReferences", "ignore references that cannot be resolved (remote schemas)")
-  .option("--noExtraKeywords", "disallow usage of keywords that this validator can't handle")
-  .option("--noTypeless", "disallow usage of schema's without \"type\" defined")
-  .option("--noEmptyStrings", "disallow zero length strings in validated objects")
-  .option("--noEmptyArrays", "disallow zero length arrays in validated objects")
-  .option("--strictUris", "forces \"uri\" format to be in fully rfc3986 compliant")
-  .option("--strictMode", "turn on some of the above")
-  .option("--reportPathAsArray", "report error paths as an array of path segments to get to the offending node")
-  .option("--breakOnFirstError", "stops validation as soon as an error is found, true by default but can be turned off")
-  .option("--pedanticCheck", "check if schema follow best practices and common sence")
-  .option("--ignoreUnknownFormats", "ignore unknown formats (do not report them as an error)")
+  .version(pkg.version)
+  .usage('[options] <schema> <json1?> <json2?> <json3?>')
+  .option('--asyncTimeout <n>', 'default timeout for all async tasks', parseInt)
+  .option(
+    '--forceAdditional',
+    'force additionalProperties and additionalItems to be defined on "object" and "array" types'
+  )
+  .option(
+    '--assumeAdditional',
+    'assume additionalProperties and additionalItems are defined as "false" where appropriate'
+  )
+  .option('--forceItems', 'force items to be defined on "array" types')
+  .option('--forceMinItems', 'force minItems to be defined on "array" types')
+  .option('--forceMaxItems', 'force maxItems to be defined on "array" types')
+  .option('--forceMinLength', 'force minLength to be defined on "string" types')
+  .option('--forceMaxLength', 'force maxLength to be defined on "string" types')
+  .option('--forceProperties', 'force properties or patternProperties to be defined on "object" types')
+  .option('--ignoreUnresolvableReferences', 'ignore references that cannot be resolved (remote schemas)')
+  .option('--noExtraKeywords', "disallow usage of keywords that this validator can't handle")
+  .option('--noTypeless', 'disallow usage of schema\'s without "type" defined')
+  .option('--noEmptyStrings', 'disallow zero length strings in validated objects')
+  .option('--noEmptyArrays', 'disallow zero length arrays in validated objects')
+  .option('--strictUris', 'forces "uri" format to be in fully rfc3986 compliant')
+  .option('--strictMode', 'turn on some of the above')
+  .option('--reportPathAsArray', 'report error paths as an array of path segments to get to the offending node')
+  .option('--breakOnFirstError', 'stops validation as soon as an error is found, true by default but can be turned off')
+  .option('--pedanticCheck', 'check if schema follow best practices and common sence')
+  .option('--ignoreUnknownFormats', 'ignore unknown formats (do not report them as an error)')
+  .allowExcessArguments()
   .parse(process.argv);
-  
-var options = {};  
+
+var options = {};
 var defaultOptions = ZSchema.getDefaultOptions();
 
 for (var key in defaultOptions) {
-    if (program[key]) {
-        options[key] = program[key];
-    }
+  if (program[key]) {
+    options[key] = program[key];
+  }
 }
 
 if (!program.args.length) {
@@ -49,20 +56,20 @@ if (!program.args.length) {
 }
 
 function readJson(fileName) {
-    var ret;
-    try {
-        ret = fs.readFileSync(fileName, { encoding: "utf8" });
-    } catch (e) {
-        console.error(e);
-        throw new Error("Couldn't read the file: " + fileName);
-    }
-    try {
-        ret = JSON.parse(ret);
-    } catch (e) {
-        console.error(e);
-        throw new Error("Couldn't parse the file as JSON: " + fileName);
-    }
-    return ret;
+  var ret;
+  try {
+    ret = fs.readFileSync(fileName, { encoding: 'utf8' });
+  } catch (e) {
+    console.error(e);
+    throw new Error("Couldn't read the file: " + fileName);
+  }
+  try {
+    ret = JSON.parse(ret);
+  } catch (e) {
+    console.error(e);
+    throw new Error("Couldn't parse the file as JSON: " + fileName);
+  }
+  return ret;
 }
 
 var validator = new ZSchema(options);
@@ -70,100 +77,97 @@ var schemaFilePath = program.args.shift();
 var schema = readJson(schemaFilePath);
 
 function validateWithAutomaticDownloads(filePath, data, schema, callback) {
+  var lastResult;
 
-    var lastResult;
+  function finish() {
+    callback(validator.getLastErrors(), lastResult);
+  }
 
-    function finish() {
-        callback(validator.getLastErrors(), lastResult);
+  function validate() {
+    if (data !== undefined) {
+      lastResult = validator.validate(data, schema);
+    } else {
+      lastResult = validator.validateSchema(schema);
     }
 
-    function validate() {
+    // console.log(lastResult);
+    // console.log(JSON.stringify(validator.getLastErrors(), null, 4));
 
-        if (data !== undefined) {
-            lastResult = validator.validate(data, schema);
-        } else {
-            lastResult = validator.validateSchema(schema);
-        }
-        
-        // console.log(lastResult);
-        // console.log(JSON.stringify(validator.getLastErrors(), null, 4));
-
-        var missingReferences = validator.getMissingRemoteReferences();
-        if (missingReferences.length > 0) {
-            var finished = 0;
-            missingReferences.forEach(function (url) {
-                var urlString = "request: " + url + " - ";
-
-                if (url.match(/^https?:/)) {
-                    request(url, function (response) {
-                        var body = "";
-                        response.on("data", function (chunk) { data += chunk; });
-                        response.on("end", function () {
-
-                            console.log(urlString + response.statusCode);
-
-                            validator.setRemoteReference(url, JSON.parse(body));
-                            finished++;
-                            if (finished === missingReferences.length) {
-                                validate();
-                            }
-                        });
-                    }).on("error", function (error) {
-                        console.error(urlString);
-                        console.error(error);
-                        process.exit(1);
-                    });
-                } else {
-                    // FUTURE: maybe else if (isFile(url)) later
-                    var referencePath = path.resolve(process.cwd(), path.dirname(filePath), url);
-                    var reference = readJson(referencePath);
-                    validator.setRemoteReference(url, reference);
-                    finished++;
-                    if (finished === missingReferences.length) {
-                        validate();
-                    }
-                }
+    var missingReferences = validator.getMissingRemoteReferences();
+    if (missingReferences.length > 0) {
+      var finished = 0;
+      missingReferences.forEach(function (url) {
+        var urlString = 'request: ' + url + ' - ';
+
+        if (url.match(/^https?:/)) {
+          request(url, function (response) {
+            var body = '';
+            response.on('data', function (chunk) {
+              data += chunk;
+            });
+            response.on('end', function () {
+              console.log(urlString + response.statusCode);
+
+              validator.setRemoteReference(url, JSON.parse(body));
+              finished++;
+              if (finished === missingReferences.length) {
+                validate();
+              }
             });
+          }).on('error', function (error) {
+            console.error(urlString);
+            console.error(error);
+            process.exit(1);
+          });
         } else {
-            finish();
+          // FUTURE: maybe else if (isFile(url)) later
+          var referencePath = path.resolve(process.cwd(), path.dirname(filePath), url);
+          var reference = readJson(referencePath);
+          validator.setRemoteReference(url, reference);
+          finished++;
+          if (finished === missingReferences.length) {
+            validate();
+          }
         }
-
+      });
+    } else {
+      finish();
     }
+  }
 
-    validate();
-
+  validate();
 }
 
 var i = 0;
 function validateJsons() {
-    if (program.args.length === 0) {
-        process.exit(process.exitCode);
-        return;
+  if (program.args.length === 0) {
+    process.exit(process.exitCode);
+    return;
+  }
+  i++;
+
+  var filePath = program.args.shift();
+  var json = readJson(filePath);
+  validateWithAutomaticDownloads(filePath, json, schema, function (errs, isValid) {
+    if (!isValid) {
+      console.log(JSON.stringify(validator.getLastErrors(), null, 4));
+      console.log('json #' + i + ' validation failed');
+      process.exitCode = 1;
+    } else {
+      console.log('json #' + i + ' validation passed');
     }
-    i++;
-    
-    var filePath = program.args.shift();
-    var json = readJson(filePath);
-    validateWithAutomaticDownloads(filePath, json, schema, function (errs, isValid) {    
-        if (!isValid) {
-            console.log(JSON.stringify(validator.getLastErrors(), null, 4));
-            console.log("json #" + i + " validation failed");
-            process.exitCode = 1;
-        } else {
-            console.log("json #" + i + " validation passed");
-        }
-        validateJsons();
-    });
+    validateJsons();
+  });
 }
 
 // validate schema
 validateWithAutomaticDownloads(schemaFilePath, undefined, schema, function (errs, isValid) {
-    if (!isValid) {
-        console.log(JSON.stringify(validator.getLastErrors(), null, 4));
-        console.log("schema validation failed");
-        process.exit(1);
-    } else {
-        console.log("schema validation passed");
-        validateJsons();
-    }    
+  if (!isValid) {
+    console.log(JSON.stringify(validator.getLastErrors(), null, 4));
+    console.log('schema validation failed');
+    process.exit(1);
+  } else {
+    console.log('schema validation passed');
+    validateJsons();
+  }
 });

package/dist/Errors.js

@@ -0,0 +1,50 @@
+export const Errors = {
+    INVALID_TYPE: 'Expected type {0} but found type {1}',
+    INVALID_FORMAT: "Object didn't pass validation for format {0}: {1}",
+    ENUM_MISMATCH: 'No enum match for: {0}',
+    ENUM_CASE_MISMATCH: 'Enum does not match case for: {0}',
+    ANY_OF_MISSING: "Data does not match any schemas from 'anyOf'",
+    ONE_OF_MISSING: "Data does not match any schemas from 'oneOf'",
+    ONE_OF_MULTIPLE: "Data is valid against more than one schema from 'oneOf'",
+    NOT_PASSED: "Data matches schema from 'not'",
+    // Array errors
+    ARRAY_LENGTH_SHORT: 'Array is too short ({0}), minimum {1}',
+    ARRAY_LENGTH_LONG: 'Array is too long ({0}), maximum {1}',
+    ARRAY_UNIQUE: 'Array items are not unique (indexes {0} and {1})',
+    ARRAY_ADDITIONAL_ITEMS: 'Additional items not allowed',
+    // Numeric errors
+    MULTIPLE_OF: 'Value {0} is not a multiple of {1}',
+    MINIMUM: 'Value {0} is less than minimum {1}',
+    MINIMUM_EXCLUSIVE: 'Value {0} is equal or less than exclusive minimum {1}',
+    MAXIMUM: 'Value {0} is greater than maximum {1}',
+    MAXIMUM_EXCLUSIVE: 'Value {0} is equal or greater than exclusive maximum {1}',
+    // Object errors
+    OBJECT_PROPERTIES_MINIMUM: 'Too few properties defined ({0}), minimum {1}',
+    OBJECT_PROPERTIES_MAXIMUM: 'Too many properties defined ({0}), maximum {1}',
+    OBJECT_MISSING_REQUIRED_PROPERTY: 'Missing required property: {0}',
+    OBJECT_ADDITIONAL_PROPERTIES: 'Additional properties not allowed: {0}',
+    OBJECT_DEPENDENCY_KEY: 'Dependency failed - key must exist: {0} (due to key: {1})',
+    // String errors
+    MIN_LENGTH: 'String is too short ({0} chars), minimum {1}',
+    MAX_LENGTH: 'String is too long ({0} chars), maximum {1}',
+    PATTERN: 'String does not match pattern {0}: {1}',
+    // Schema validation errors
+    KEYWORD_TYPE_EXPECTED: "Keyword '{0}' is expected to be of type '{1}'",
+    KEYWORD_UNDEFINED_STRICT: "Keyword '{0}' must be defined in strict mode",
+    KEYWORD_UNEXPECTED: "Keyword '{0}' is not expected to appear in the schema",
+    KEYWORD_MUST_BE: "Keyword '{0}' must be {1}",
+    KEYWORD_DEPENDENCY: "Keyword '{0}' requires keyword '{1}'",
+    KEYWORD_PATTERN: "Keyword '{0}' is not a valid RegExp pattern: {1}",
+    KEYWORD_VALUE_TYPE: "Each element of keyword '{0}' array must be a '{1}'",
+    UNKNOWN_FORMAT: "There is no validation function for format '{0}'",
+    CUSTOM_MODE_FORCE_PROPERTIES: '{0} must define at least one property if present',
+    // Remote errors
+    REF_UNRESOLVED: 'Reference has not been resolved during compilation: {0}',
+    UNRESOLVABLE_REFERENCE: 'Reference could not be resolved: {0}',
+    SCHEMA_NOT_REACHABLE: 'Validator was not able to read schema with uri: {0}',
+    SCHEMA_TYPE_EXPECTED: "Schema is expected to be of type 'object'",
+    SCHEMA_NOT_AN_OBJECT: 'Schema is not an object: {0}',
+    ASYNC_TIMEOUT: '{0} asynchronous task(s) have timed out after {1} ms',
+    PARENT_SCHEMA_VALIDATION_FAILED: 'Schema failed to validate against its parent schema, see inner errors for details.',
+    REMOTE_NOT_VALID: "Remote reference didn't compile successfully: {0}",
+};

package/dist/FormatValidators.js

@@ -0,0 +1,136 @@
+import validator from 'validator';
+export const FormatValidators = {
+    date: function (date) {
+        if (typeof date !== 'string') {
+            return true;
+        }
+        // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
+        const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
+        if (matches === null) {
+            return false;
+        }
+        // var year = matches[1];
+        // var month = matches[2];
+        // var day = matches[3];
+        if (matches[2] < '01' || matches[2] > '12' || matches[3] < '01' || matches[3] > '31') {
+            return false;
+        }
+        return true;
+    },
+    'date-time': function (dateTime) {
+        if (typeof dateTime !== 'string') {
+            return true;
+        }
+        // date-time from http://tools.ietf.org/html/rfc3339#section-5.6
+        const s = dateTime.toLowerCase().split('t');
+        if (!FormatValidators.date(s[0])) {
+            return false;
+        }
+        const matches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/.exec(s[1]);
+        if (matches === null) {
+            return false;
+        }
+        // var hour = matches[1];
+        // var minute = matches[2];
+        // var second = matches[3];
+        // var fraction = matches[4];
+        // var timezone = matches[5];
+        if (matches[1] > '23' || matches[2] > '59' || matches[3] > '59') {
+            return false;
+        }
+        return true;
+    },
+    email: function (email) {
+        if (typeof email !== 'string') {
+            return true;
+        }
+        return validator.isEmail(email, { require_tld: true });
+    },
+    hostname: function (hostname) {
+        if (typeof hostname !== 'string') {
+            return true;
+        }
+        /*
+                http://json-schema.org/latest/json-schema-validation.html#anchor114
+                A string instance is valid against this attribute if it is a valid
+                representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
+    
+                http://tools.ietf.org/html/rfc1034#section-3.5
+    
+                <digit> ::= any one of the ten digits 0 through 9
+                var digit = /[0-9]/;
+    
+                <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
+                var letter = /[a-zA-Z]/;
+    
+                <let-dig> ::= <letter> | <digit>
+                var letDig = /[0-9a-zA-Z]/;
+    
+                <let-dig-hyp> ::= <let-dig> | "-"
+                var letDigHyp = /[-0-9a-zA-Z]/;
+    
+                <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+                var ldhStr = /[-0-9a-zA-Z]+/;
+    
+                <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
+                var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
+    
+                <subdomain> ::= <label> | <subdomain> "." <label>
+                var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
+    
+                <domain> ::= <subdomain> | " "
+                var domain = null;
+            */
+        const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);
+        if (valid) {
+            // the sum of all label octets and label lengths is limited to 255.
+            if (hostname.length > 255) {
+                return false;
+            }
+            // Each node has a label, which is zero to 63 octets in length
+            const labels = hostname.split('.');
+            for (let i = 0; i < labels.length; i++) {
+                if (labels[i].length > 63) {
+                    return false;
+                }
+            }
+        }
+        return valid;
+    },
+    'host-name': function (hostname) {
+        return FormatValidators.hostname.call(this, hostname);
+    },
+    ipv4: function (ipv4) {
+        if (typeof ipv4 !== 'string') {
+            return true;
+        }
+        return validator.isIP(ipv4, 4);
+    },
+    ipv6: function (ipv6) {
+        if (typeof ipv6 !== 'string') {
+            return true;
+        }
+        return validator.isIP(ipv6, 6);
+    },
+    regex: function (str) {
+        try {
+            RegExp(str);
+            return true;
+        }
+        catch (_e) {
+            return false;
+        }
+    },
+    uri: function (...args) {
+        if (this.options.strictUris) {
+            return FormatValidators['strict-uri'].apply(this, args);
+        }
+        const [uri] = args;
+        // https://github.com/zaggino/z-schema/issues/18
+        // RegExp from http://tools.ietf.org/html/rfc3986#appendix-B
+        return typeof uri !== 'string' || RegExp('^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?').test(uri);
+    },
+    'strict-uri': function (uri) {
+        return typeof uri !== 'string' || validator.isURL(uri);
+    },
+};