json-schema-library 5.2.1 → 6.1.0

package/lib/validation/keyword.ts

@@ -2,31 +2,41 @@ import getTypeOf from "../getTypeOf";
 import isSame from "../utils/deepCompare";
 import settings from "../config/settings";
 import ucs2decode from "../utils/punycode.ucs2decode";
+import { JSONValidator, isJSONError } from "../types";
 const FPP = settings.floatingPointPrecision;
 
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasProperty = (value: Record<string, unknown>, property: string) =>
+    !(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 = {
-
+const KeywordValidation: Record<string, JSONValidator> = {
     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
@@ -45,37 +55,48 @@ const KeywordValidation = {
                 // additionalProperties { oneOf: [] }
                 if (isObject && Array.isArray(schema.additionalProperties.oneOf)) {
                     const result = core.resolveOneOf(
-                        value[property], schema.additionalProperties, `${pointer}/${property}`
+                        value[property],
+                        schema.additionalProperties,
+                        `${pointer}/${property}`
                     );
-                    if (result.type === "error") {
-                        errors.push(core.errors.additionalPropertiesError({
-                            schema: schema.additionalProperties,
-                            property: receivedProperties[i],
-                            properties: expectedProperties,
-                            pointer,
-                            // pass all validation errors
-                            errors: result.data.errors
-                        }));
-
+                    if (isJSONError(result)) {
+                        errors.push(
+                            core.errors.additionalPropertiesError({
+                                schema: schema.additionalProperties,
+                                property: receivedProperties[i],
+                                properties: expectedProperties,
+                                pointer,
+                                // pass all validation errors
+                                errors: result.data.errors
+                            })
+                        );
                     } else {
                         errors.push(core.validate(value[property], result, pointer));
                     }
 
-                // additionalProperties {}
+                    // additionalProperties {}
                 } else if (isObject) {
-                    if (core.validate(value[property], schema.additionalProperties, pointer).length !== 0) {
-                        errors.push(core.errors.additionalPropertiesError({
-                            schema: schema.additionalProperties,
+                    if (
+                        core.validate(value[property], schema.additionalProperties, pointer)
+                            .length !== 0
+                    ) {
+                        errors.push(
+                            core.errors.additionalPropertiesError({
+                                schema: schema.additionalProperties,
+                                property: receivedProperties[i],
+                                properties: expectedProperties,
+                                pointer
+                            })
+                        );
+                    }
+                } else {
+                    errors.push(
+                        core.errors.noAdditionalPropertiesError({
                             property: receivedProperties[i],
                             properties: expectedProperties,
                             pointer
-                        }));
-                    }
-
-                } else {
-                    errors.push(core.errors.noAdditionalPropertiesError(
-                        { property: receivedProperties[i], properties: expectedProperties, pointer }
-                    ));
+                        })
+                    );
                 }
             }
         }
@@ -89,7 +110,7 @@ const KeywordValidation = {
         }
 
         const errors = [];
-        schema.allOf.forEach(subSchema => {
+        schema.allOf.forEach((subSchema) => {
             errors.push(core.validate(value, subSchema, pointer));
         });
 
@@ -116,32 +137,43 @@ const KeywordValidation = {
         }
 
         const errors = [];
-        Object.keys(value)
-            .forEach(property => {
-                if (schema.dependencies[property] === undefined) {
-                    return;
-                }
+        Object.keys(value).forEach((property) => {
+            if (schema.dependencies[property] === undefined) {
+                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 }));
-                } else if (type === "object") {
-                    dependencyErrors = core.validate(value, schema.dependencies[property]);
+            // @draft >= 6 boolean schema
+            if (schema.dependencies[property] === true) {
+                return;
+            }
+            if (schema.dependencies[property] === false) {
+                errors.push(core.errors.missingDependencyError({ pointer }));
+                return;
+            }
 
-                } else {
-                    throw new Error(`Invalid dependency definition for ${pointer}/${property}. Must be list or schema`);
-                }
+            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 })
+                    );
+            } else if (type === "object") {
+                dependencyErrors = core.validate(value, schema.dependencies[property]);
+            } else {
+                throw new Error(
+                    `Invalid dependency definition for ${pointer}/${property}. Must be list or schema`
+                );
+            }
 
-                errors.push(...dependencyErrors);
-            });
+            errors.push(...dependencyErrors);
+        });
 
         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);
@@ -164,13 +196,20 @@ 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];
             }
 
@@ -197,7 +236,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;
     },
@@ -207,7 +250,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;
     },
@@ -228,7 +275,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;
     },
@@ -249,7 +300,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;
     },
@@ -261,7 +316,8 @@ const KeywordValidation = {
         if (schema.minProperties > propertyCount) {
             return core.errors.minPropertiesError({
                 minProperties: schema.minProperties,
-                length: propertyCount, pointer
+                length: propertyCount,
+                pointer
             });
         }
         return undefined;
@@ -272,9 +328,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) => {
@@ -290,7 +347,7 @@ const KeywordValidation = {
         }
 
         schema = core.resolveOneOf(value, schema, pointer);
-        if (schema && schema.type === "error") {
+        if (isJSONError(schema)) {
             return schema;
         }
 
@@ -302,7 +359,8 @@ const KeywordValidation = {
             return core.errors.patternError({
                 pattern: schema.pattern,
                 description: schema.patternExample || schema.pattern,
-                received: value, pointer
+                received: value,
+                pointer
             });
         }
         return undefined;
@@ -316,18 +374,22 @@ 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)) {
                     patternFound = true;
-                    const valErrors = core.validate(value[key], patterns[i].patternSchema, `${pointer}/${key}`);
+                    const valErrors = core.validate(
+                        value[key],
+                        patterns[i].patternSchema,
+                        `${pointer}/${key}`
+                    );
                     if (valErrors && valErrors.length > 0) {
                         errors.push(...valErrors);
                     }
@@ -340,9 +402,13 @@ 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(",")
-                }));
+                errors.push(
+                    core.errors.patternPropertiesError({
+                        key,
+                        pointer,
+                        patterns: Object.keys(pp).join(",")
+                    })
+                );
             }
         });
 
@@ -353,7 +419,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);
@@ -377,13 +443,13 @@ const KeywordValidation = {
         }
         return errors;
     },
-    required: (core, schema, value, pointer) => {
+    required: (core, schema, value: Record<string, unknown>, pointer) => {
         if (Array.isArray(schema.required) === false) {
             return undefined;
         }
 
-        return schema.required.map(property => {
-            if (value[property] === undefined) {
+        return schema.required.map((property: string) => {
+            if (!hasProperty(value, property)) {
                 return core.errors.requiredPropertyError({ key: property, pointer });
             }
             return undefined;
@@ -395,9 +461,12 @@ const KeywordValidation = {
             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;
         });
@@ -411,12 +480,14 @@ const KeywordValidation = {
         value.forEach((item, index) => {
             for (let i = index + 1; i < value.length; i += 1) {
                 if (isSame(item, value[i])) {
-                    errors.push(core.errors.uniqueItemsError({
-                        pointer,
-                        itemPointer: `${pointer}/${index}`,
-                        duplicatePointer: `${pointer}/${i}`,
-                        value: JSON.stringify(item)
-                    }));
+                    errors.push(
+                        core.errors.uniqueItemsError({
+                            pointer,
+                            itemPointer: `${pointer}/${index}`,
+                            duplicatePointer: `${pointer}/${i}`,
+                            value: JSON.stringify(item)
+                        })
+                    );
                 }
             }
         });
@@ -425,6 +496,4 @@ const KeywordValidation = {
     }
 };
 
-
 export default KeywordValidation;
-

package/lib/validation/type.ts

@@ -1,3 +1,5 @@
+import { JSONTypeValidator } from "../types";
+
 /**
  * @todo: type is also a keyword, as is properties, items, etc
  *
@@ -5,7 +7,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: Record<string, JSONTypeValidator> = {
 
     array: (core, schema, value, pointer) =>
         core.typeKeywords.array
@@ -42,3 +44,5 @@ export default {
             .filter(key => schema && schema[key] != null)
             .map(key => core.validateKeyword[key](core, schema, value, pointer))
 };
+
+export default typeValidators;

package/package.json

@@ -1,65 +1,75 @@
 {
-  "name": "json-schema-library",
-  "version": "5.2.1",
-  "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
-  "module": "dist/module/index.js",
-  "types": "dist/index.d.ts",
-  "main": "dist/jsonSchemaLibrary.js",
-  "scripts": {
-    "dist": "rm -rf dist; yarn dist:es5 && yarn dist:es6",
-    "dist:es5": "NODE_ENV=production webpack",
-    "dist:es6": "tsc --outDir dist/module --target ES2019",
-    "test": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/**/*.test.ts'",
-    "test:integration": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/integration/**/*.test.ts'",
-    "test:unit": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/unit/**/*.test.ts'",
-    "test:spec": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/spec/**/*.test.ts'",
-    "tdd": "watch \"npm run test:unit\" lib/ test/",
-    "coverage": "nyc npm run test --reporter=lcov",
-    "analyze": "NODE_ENV=production webpack --json | webpack-bundle-size-analyzer",
-    "lint": "eslint lib"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/sagold/json-schema-library.git"
-  },
-  "author": "Sascha Goldhofer <github@saschagoldhofer.de> (https://github.com/sagold/)",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/sagold/json-schema-library/issues"
-  },
-  "homepage": "https://github.com/sagold/json-schema-library",
-  "devDependencies": {
-    "@types/chai": "^4.2.14",
-    "@types/mocha": "^8.0.4",
-    "@types/node": "^14.14.10",
-    "@typescript-eslint/eslint-plugin": "^4.7.0",
-    "@typescript-eslint/parser": "^4.7.0",
-    "chai": "^4.2.0",
-    "chalk": "^2.3.0",
-    "eslint": "^7.13.0",
-    "eslint-plugin-array-func": "^3.1.7",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-optimize-regex": "^1.2.0",
-    "eslint-plugin-promise": "^4.2.1",
-    "glob": "^7.1.2",
-    "json-schema-test-suite": "json-schema-org/JSON-Schema-Test-Suite.git#master",
-    "mocha": "^3.1.2",
-    "nyc": "^10.0.0",
-    "terser-webpack-plugin": "^5.0.3",
-    "ts-loader": "^8.0.11",
-    "ts-node": "^9.0.0",
-    "typescript": "^4.1.3",
-    "watch": "^1.0.1",
-    "webpack": "^5.9.0",
-    "webpack-cli": "^4.2.0"
-  },
-  "dependencies": {
-    "deepmerge": "^4.2.2",
-    "gson-pointer": "^4.1.1",
-    "gson-query": "^5.1.0",
-    "valid-url": "^1.0.9"
-  },
-  "publishConfig": {
-    "registry": "http://registry.npmjs.org"
-  }
+    "name": "json-schema-library",
+    "version": "6.1.0",
+    "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
+    "module": "dist/module/index.js",
+    "types": "dist/index.d.ts",
+    "main": "dist/jsonSchemaLibrary.js",
+    "scripts": {
+        "dist": "rm -rf dist; yarn dist:es5 && yarn dist:es6",
+        "dist:es5": "NODE_ENV=production webpack",
+        "dist:es6": "tsc --outDir dist/module --target ES2019",
+        "test": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/**/*.test.ts'",
+        "test:integration": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/integration/**/*.test.ts'",
+        "test:unit": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/unit/**/*.test.ts'",
+        "test:spec": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/spec/**/*.test.ts'",
+        "test:4": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/spec/v4/*.test.ts'",
+        "test:6": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/spec/v6/*.test.ts'",
+        "test:7": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/spec/v7/*.test.ts'",
+        "test:2019": "TS_NODE_PROJECT=./test/tsconfig.json mocha -r ts-node/register -R spec 'test/spec/v2019-09/*.test.ts'",
+        "tdd": "watch \"npm run test:unit\" lib/ test/",
+        "coverage": "nyc npm run test --reporter=lcov",
+        "analyze": "NODE_ENV=production webpack --json | webpack-bundle-size-analyzer",
+        "lint": "eslint lib",
+        "prepublishOnly": "yarn dist"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/sagold/json-schema-library.git"
+    },
+    "author": "Sascha Goldhofer <github@saschagoldhofer.de> (https://github.com/sagold/)",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/sagold/json-schema-library/issues"
+    },
+    "homepage": "https://github.com/sagold/json-schema-library",
+    "devDependencies": {
+        "@types/chai": "^4.2.14",
+        "@types/mocha": "^9.1.1",
+        "@types/node": "^14.14.10",
+        "@typescript-eslint/eslint-plugin": "^5.20.0",
+        "@typescript-eslint/parser": "^5.20.0",
+        "chai": "^4.2.0",
+        "chalk": "^2.3.0",
+        "eslint": "^8.14.0",
+        "eslint-plugin-array-func": "^3.1.7",
+        "eslint-plugin-node": "^11.1.0",
+        "eslint-plugin-optimize-regex": "^1.2.0",
+        "eslint-plugin-promise": "^6.0.0",
+        "glob": "^8.0.1",
+        "json-schema-test-suite": "https://github.com/json-schema-org/JSON-Schema-Test-Suite",
+        "mocha": "^9.2.2",
+        "nyc": "^15.1.0",
+        "terser-webpack-plugin": "^5.0.3",
+        "ts-loader": "^9.2.8",
+        "ts-node": "^10.7.0",
+        "typescript": "^4.6.4",
+        "watch": "^1.0.1",
+        "webpack": "^5.9.0",
+        "webpack-cli": "^4.2.0"
+    },
+    "dependencies": {
+        "deepmerge": "^4.2.2",
+        "fast-deep-equal": "^3.1.3",
+        "gson-pointer": "^4.1.1",
+        "gson-query": "^5.1.0",
+        "valid-url": "^1.0.9"
+    },
+    "resolutions": {
+        "lodash": "4.x",
+        "merge": "2.x"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org"
+    }
 }