z-schema 6.0.2 → 7.0.0-beta.2

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);
+    },
+};