json-schema-library 5.2.1 → 6.1.0

package/dist/module/lib/validation/keyword.js

@@ -2,25 +2,29 @@ import getTypeOf from "../getTypeOf";
 import isSame from "../utils/deepCompare";
 import settings from "../config/settings";
 import ucs2decode from "../utils/punycode.ucs2decode";
+import { isJSONError } from "../types";
 const FPP = settings.floatingPointPrecision;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasProperty = (value, property) => !(value[property] === undefined || !hasOwnProperty.call(value, property));
 // list of validation keywords: http://json-schema.org/latest/json-schema-validation.html#rfc.section.5
 const KeywordValidation = {
     additionalProperties: (core, schema, value, pointer) => {
         if (schema.additionalProperties === true || schema.additionalProperties == null) {
             return undefined;
         }
-        if (getTypeOf(schema.patternProperties) === "object" && schema.additionalProperties === false) {
+        if (getTypeOf(schema.patternProperties) === "object" &&
+            schema.additionalProperties === false) {
             // this is an arrangement with patternProperties. patternProperties validate before additionalProperties:
             // https://spacetelescope.github.io/understanding-json-schema/reference/object.html#index-5
             return undefined;
         }
         const errors = [];
-        let receivedProperties = Object.keys(value).filter(prop => settings.propertyBlacklist.includes(prop) === false);
+        let receivedProperties = Object.keys(value).filter((prop) => settings.propertyBlacklist.includes(prop) === false);
         const expectedProperties = Object.keys(schema.properties || {});
         if (getTypeOf(schema.patternProperties) === "object") {
             // filter received properties by matching patternProperties
-            const patterns = Object.keys(schema.patternProperties).map(pattern => new RegExp(pattern));
-            receivedProperties = receivedProperties.filter(prop => {
+            const patterns = Object.keys(schema.patternProperties).map((pattern) => new RegExp(pattern));
+            receivedProperties = receivedProperties.filter((prop) => {
                 for (let i = 0; i < patterns.length; i += 1) {
                     if (patterns[i].test(prop)) {
                         return false; // remove
@@ -37,7 +41,7 @@ const KeywordValidation = {
                 // additionalProperties { oneOf: [] }
                 if (isObject && Array.isArray(schema.additionalProperties.oneOf)) {
                     const result = core.resolveOneOf(value[property], schema.additionalProperties, `${pointer}/${property}`);
-                    if (result.type === "error") {
+                    if (isJSONError(result)) {
                         errors.push(core.errors.additionalPropertiesError({
                             schema: schema.additionalProperties,
                             property: receivedProperties[i],
@@ -53,7 +57,8 @@ const KeywordValidation = {
                     // additionalProperties {}
                 }
                 else if (isObject) {
-                    if (core.validate(value[property], schema.additionalProperties, pointer).length !== 0) {
+                    if (core.validate(value[property], schema.additionalProperties, pointer)
+                        .length !== 0) {
                         errors.push(core.errors.additionalPropertiesError({
                             schema: schema.additionalProperties,
                             property: receivedProperties[i],
@@ -63,7 +68,11 @@ const KeywordValidation = {
                     }
                 }
                 else {
-                    errors.push(core.errors.noAdditionalPropertiesError({ property: receivedProperties[i], properties: expectedProperties, pointer }));
+                    errors.push(core.errors.noAdditionalPropertiesError({
+                        property: receivedProperties[i],
+                        properties: expectedProperties,
+                        pointer
+                    }));
                 }
             }
         }
@@ -74,7 +83,7 @@ const KeywordValidation = {
             return undefined;
         }
         const errors = [];
-        schema.allOf.forEach(subSchema => {
+        schema.allOf.forEach((subSchema) => {
             errors.push(core.validate(value, subSchema, pointer));
         });
         return errors;
@@ -95,17 +104,24 @@ const KeywordValidation = {
             return undefined;
         }
         const errors = [];
-        Object.keys(value)
-            .forEach(property => {
+        Object.keys(value).forEach((property) => {
             if (schema.dependencies[property] === undefined) {
                 return;
             }
+            // @draft >= 6 boolean schema
+            if (schema.dependencies[property] === true) {
+                return;
+            }
+            if (schema.dependencies[property] === false) {
+                errors.push(core.errors.missingDependencyError({ pointer }));
+                return;
+            }
             let dependencyErrors;
             const type = getTypeOf(schema.dependencies[property]);
             if (type === "array") {
                 dependencyErrors = schema.dependencies[property]
-                    .filter(dependency => value[dependency] === undefined)
-                    .map(missingProperty => core.errors.missingDependencyError({ missingProperty, pointer }));
+                    .filter((dependency) => value[dependency] === undefined)
+                    .map((missingProperty) => core.errors.missingDependencyError({ missingProperty, pointer }));
             }
             else if (type === "object") {
                 dependencyErrors = core.validate(value, schema.dependencies[property]);
@@ -117,7 +133,7 @@ const KeywordValidation = {
         });
         return errors.length > 0 ? errors : undefined;
     },
-    "enum": (core, schema, value, pointer) => {
+    enum: (core, schema, value, pointer) => {
         const type = getTypeOf(value);
         if (type === "object" || type === "array") {
             const valueStr = JSON.stringify(value);
@@ -141,12 +157,19 @@ const KeywordValidation = {
         return undefined;
     },
     items: (core, schema, value, pointer) => {
+        // @draft >= 7 bool schema
+        if (schema.items === false) {
+            if (Array.isArray(value) && value.length === 0) {
+                return undefined;
+            }
+            return core.errors.invalidDataError({ pointer, value });
+        }
         const errors = [];
         for (let i = 0; i < value.length; i += 1) {
             const itemData = value[i];
             // @todo reevaluate: incomplete schema is created here
             const itemSchema = core.step(i, schema, value, pointer);
-            if (itemSchema && itemSchema.type === "error") {
+            if (isJSONError(itemSchema)) {
                 return [itemSchema];
             }
             const itemErrors = core.validate(itemData, itemSchema, `${pointer}/${i}`);
@@ -171,7 +194,11 @@ const KeywordValidation = {
             return undefined;
         }
         if (schema.maxItems < value.length) {
-            return core.errors.maxItemsError({ maximum: schema.maxItems, length: value.length, pointer });
+            return core.errors.maxItemsError({
+                maximum: schema.maxItems,
+                length: value.length,
+                pointer
+            });
         }
         return undefined;
     },
@@ -181,7 +208,11 @@ const KeywordValidation = {
         }
         const lengthOfString = ucs2decode(value).length;
         if (schema.maxLength < lengthOfString) {
-            return core.errors.maxLengthError({ maxLength: schema.maxLength, length: lengthOfString, pointer });
+            return core.errors.maxLengthError({
+                maxLength: schema.maxLength,
+                length: lengthOfString,
+                pointer
+            });
         }
         return undefined;
     },
@@ -202,7 +233,11 @@ const KeywordValidation = {
         }
         const lengthOfString = ucs2decode(value).length;
         if (schema.minLength > lengthOfString) {
-            return core.errors.minLengthError({ minLength: schema.minLength, length: lengthOfString, pointer });
+            return core.errors.minLengthError({
+                minLength: schema.minLength,
+                length: lengthOfString,
+                pointer
+            });
         }
         return undefined;
     },
@@ -223,7 +258,11 @@ const KeywordValidation = {
             return undefined;
         }
         if (schema.minItems > value.length) {
-            return core.errors.minItemsError({ minItems: schema.minItems, length: value.length, pointer });
+            return core.errors.minItemsError({
+                minItems: schema.minItems,
+                length: value.length,
+                pointer
+            });
         }
         return undefined;
     },
@@ -235,7 +274,8 @@ const KeywordValidation = {
         if (schema.minProperties > propertyCount) {
             return core.errors.minPropertiesError({
                 minProperties: schema.minProperties,
-                length: propertyCount, pointer
+                length: propertyCount,
+                pointer
             });
         }
         return undefined;
@@ -246,9 +286,10 @@ const KeywordValidation = {
         }
         // https://github.com/cfworker/cfworker/blob/master/packages/json-schema/src/validate.ts#L1061
         // https://github.com/ExodusMovement/schemasafe/blob/master/src/compile.js#L441
-        if ((value * FPP) % (schema.multipleOf * FPP) / FPP !== 0) {
+        if (((value * FPP) % (schema.multipleOf * FPP)) / FPP !== 0) {
             return core.errors.multipleOfError({ multipleOf: schema.multipleOf, value, pointer });
         }
+        // also check https://stackoverflow.com/questions/1815367/catch-and-compute-overflow-during-multiplication-of-two-large-integers
         return undefined;
     },
     not: (core, schema, value, pointer) => {
@@ -263,7 +304,7 @@ const KeywordValidation = {
             return undefined;
         }
         schema = core.resolveOneOf(value, schema, pointer);
-        if (schema && schema.type === "error") {
+        if (isJSONError(schema)) {
             return schema;
         }
         return undefined;
@@ -274,7 +315,8 @@ const KeywordValidation = {
             return core.errors.patternError({
                 pattern: schema.pattern,
                 description: schema.patternExample || schema.pattern,
-                received: value, pointer
+                received: value,
+                pointer
             });
         }
         return undefined;
@@ -287,11 +329,11 @@ const KeywordValidation = {
         }
         const errors = [];
         const keys = Object.keys(value);
-        const patterns = Object.keys(pp).map(expr => ({
+        const patterns = Object.keys(pp).map((expr) => ({
             regex: new RegExp(expr),
             patternSchema: pp[expr]
         }));
-        keys.forEach(key => {
+        keys.forEach((key) => {
             let patternFound = false;
             for (let i = 0, l = patterns.length; i < l; i += 1) {
                 if (patterns[i].regex.test(key)) {
@@ -308,7 +350,9 @@ const KeywordValidation = {
             if (patternFound === false && schema.additionalProperties === false) {
                 // this is an arrangement with additionalProperties
                 errors.push(core.errors.patternPropertiesError({
-                    key, pointer, patterns: Object.keys(pp).join(",")
+                    key,
+                    pointer,
+                    patterns: Object.keys(pp).join(",")
                 }));
             }
         });
@@ -319,7 +363,7 @@ const KeywordValidation = {
         const keys = Object.keys(schema.properties || {});
         for (let i = 0; i < keys.length; i += 1) {
             const key = keys[i];
-            if (value[key] !== undefined) {
+            if (hasProperty(value, key)) {
                 const itemSchema = core.step(key, schema, value, pointer);
                 const keyErrors = core.validate(value[key], itemSchema, `${pointer}/${key}`);
                 errors.push(...keyErrors);
@@ -348,8 +392,8 @@ const KeywordValidation = {
         if (Array.isArray(schema.required) === false) {
             return undefined;
         }
-        return schema.required.map(property => {
-            if (value[property] === undefined) {
+        return schema.required.map((property) => {
+            if (!hasProperty(value, property)) {
                 return core.errors.requiredPropertyError({ key: property, pointer });
             }
             return undefined;
@@ -360,9 +404,12 @@ const KeywordValidation = {
         if (Array.isArray(schema.required) === false) {
             return undefined;
         }
-        return schema.required.map(property => {
+        return schema.required.map((property) => {
             if (value[property] == null || value[property] === "") {
-                return core.errors.valueNotEmptyError({ property, pointer: `${pointer}/${property}` });
+                return core.errors.valueNotEmptyError({
+                    property,
+                    pointer: `${pointer}/${property}`
+                });
             }
             return undefined;
         });

package/dist/module/lib/validation/type.js

@@ -5,7 +5,7 @@
  * or seven in case of ajv https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#type
  * 1 null, 2 boolean, 3 object, 4 array, 5 number, 6 string (7 integer)
  */
-export default {
+const typeValidators = {
     array: (core, schema, value, pointer) => core.typeKeywords.array
         .filter(key => schema && schema[key] != null)
         .map(key => core.validateKeyword[key](core, schema, value, pointer)),
@@ -28,3 +28,4 @@ export default {
         .filter(key => schema && schema[key] != null)
         .map(key => core.validateKeyword[key](core, schema, value, pointer))
 };
+export default typeValidators;

package/dist/module/remotes/draft06.json

@@ -0,0 +1,155 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$id": "http://json-schema.org/draft-06/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "examples": {
+            "type": "array",
+            "items": {}
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": {},
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": {}
+}

package/dist/module/remotes/draft07.json

@@ -0,0 +1,172 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$id": "http://json-schema.org/draft-07/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": true
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true,
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "if": { "$ref": "#" },
+        "then": { "$ref": "#" },
+        "else": { "$ref": "#" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": true
+}

package/dist/module/remotes/index.js

@@ -1,5 +1,4 @@
 export default {
-    "http://json-schema.org/draft-04/schema": require("./draft04.json"),
     reset() {
         Object.keys(this).forEach(key => {
             if (typeof this[key] !== "function" && key !== "http://json-schema.org/draft-04/schema") {

package/dist/remotes/index.d.ts

@@ -1,5 +1,4 @@
 declare const _default: {
-    "http://json-schema.org/draft-04/schema": any;
     reset(): void;
 };
 export default _default;