json-schema-library 5.3.0 → 7.0.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, JSONSchema, JSONError } 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 = {
-
-    additionalProperties: (core, schema, value, pointer) => {
+const KeywordValidation: Record<string, JSONValidator> = {
+    additionalProperties: (core, schema, value: Record<string, unknown>, 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);
+        const errors: JSONError[] = [];
+        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));
+                        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 }
-                    ));
+                        })
+                    );
                 }
             }
         }
@@ -88,9 +109,9 @@ const KeywordValidation = {
             return undefined;
         }
 
-        const errors = [];
-        schema.allOf.forEach(subSchema => {
-            errors.push(core.validate(value, subSchema, pointer));
+        const errors: JSONError[] = [];
+        schema.allOf.forEach((subSchema: JSONSchema) => {
+            errors.push(...core.validate(value, subSchema, pointer));
         });
 
         return errors;
@@ -110,38 +131,49 @@ const KeywordValidation = {
         return core.errors.anyOfError({ anyOf: schema.anyOf, value, pointer });
     },
 
-    dependencies: (core, schema, value, pointer) => {
+    dependencies: (core, schema, value: Record<string, unknown>, pointer) => {
         if (getTypeOf(schema.dependencies) !== "object") {
             return undefined;
         }
 
-        const errors = [];
-        Object.keys(value)
-            .forEach(property => {
-                if (schema.dependencies[property] === undefined) {
-                    return;
-                }
+        const errors: JSONError[] = [];
+        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: any) => value[dependency] === undefined)
+                    .map((missingProperty: any) =>
+                        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);
@@ -163,14 +195,21 @@ const KeywordValidation = {
         // fail silently if given format is not defined
         return undefined;
     },
-    items: (core, schema, value, pointer) => {
-        const errors = [];
+    items: (core, schema, value: unknown[], 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: JSONError[] = [];
         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];
             }
 
@@ -192,22 +231,30 @@ const KeywordValidation = {
         }
         return undefined;
     },
-    maxItems: (core, schema, value, pointer) => {
+    maxItems: (core, schema, value: unknown[], pointer) => {
         if (isNaN(schema.maxItems)) {
             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;
     },
-    maxLength: (core, schema, value, pointer) => {
+    maxLength: (core, schema, value: string, pointer) => {
         if (isNaN(schema.maxLength)) {
             return undefined;
         }
         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;
     },
@@ -222,13 +269,17 @@ const KeywordValidation = {
         }
         return undefined;
     },
-    minLength: (core, schema, value, pointer) => {
+    minLength: (core, schema, value: string, pointer) => {
         if (isNaN(schema.minLength)) {
             return undefined;
         }
         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;
     },
@@ -244,12 +295,16 @@ const KeywordValidation = {
         }
         return undefined;
     },
-    minItems: (core, schema, value, pointer) => {
+    minItems: (core, schema, value: unknown[], pointer) => {
         if (isNaN(schema.minItems)) {
             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,24 +316,26 @@ const KeywordValidation = {
         if (schema.minProperties > propertyCount) {
             return core.errors.minPropertiesError({
                 minProperties: schema.minProperties,
-                length: propertyCount, pointer
+                length: propertyCount,
+                pointer
             });
         }
         return undefined;
     },
-    multipleOf: (core, schema, value, pointer) => {
+    multipleOf: (core, schema, value: number, pointer) => {
         if (isNaN(schema.multipleOf)) {
             return undefined;
         }
         // 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) => {
-        const errors = [];
+        const errors: JSONError[] = [];
         if (core.validate(value, schema.not, pointer).length === 0) {
             errors.push(core.errors.notError({ value, not: schema.not, pointer }));
         }
@@ -290,44 +347,49 @@ const KeywordValidation = {
         }
 
         schema = core.resolveOneOf(value, schema, pointer);
-        if (schema && schema.type === "error") {
+        if (isJSONError(schema)) {
             return schema;
         }
 
         return undefined;
     },
-    pattern: (core, schema, value, pointer) => {
+    pattern: (core, schema, value: string, pointer) => {
         const pattern = new RegExp(schema.pattern, "u");
         if (pattern.test(value) === false) {
             return core.errors.patternError({
                 pattern: schema.pattern,
                 description: schema.patternExample || schema.pattern,
-                received: value, pointer
+                received: value,
+                pointer
             });
         }
         return undefined;
     },
-    patternProperties: (core, schema, value, pointer) => {
+    patternProperties: (core, schema, value: Record<string, unknown>, pointer) => {
         const properties = schema.properties || {};
         const pp = schema.patternProperties;
         if (getTypeOf(pp) !== "object") {
             return undefined;
         }
 
-        const errors = [];
+        const errors: JSONError[] = [];
         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,20 +402,24 @@ 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(",")
+                    })
+                );
             }
         });
 
         return errors;
     },
-    properties: (core, schema, value, pointer) => {
-        const errors = [];
+    properties: (core, schema, value: Record<string, unknown>, pointer) => {
+        const errors: JSONError[] = [];
         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);
@@ -362,8 +428,8 @@ const KeywordValidation = {
         return errors;
     },
     // @todo move to separate file: this is custom keyword validation for JsonEditor.properties keyword
-    propertiesRequired: (core, schema, value, pointer) => {
-        const errors = [];
+    propertiesRequired: (core, schema, value: Record<string, unknown>, pointer) => {
+        const errors: JSONError[] = [];
         const keys = Object.keys(schema.properties || {});
         for (let i = 0; i < keys.length; i += 1) {
             const key = keys[i];
@@ -377,46 +443,51 @@ 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;
         });
     },
     // @todo move to separate file: this is custom keyword validation for JsonEditor.required keyword
-    requiredNotEmpty: (core, schema, value, pointer) => {
+    requiredNotEmpty: (core, schema, value: Record<string, unknown>, pointer) => {
         if (Array.isArray(schema.required) === false) {
             return undefined;
         }
 
-        return schema.required.map(property => {
+        return schema.required.map((property: string) => {
             if (value[property] == null || value[property] === "") {
-                return core.errors.valueNotEmptyError({ property, pointer: `${pointer}/${property}` });
+                return core.errors.valueNotEmptyError({
+                    property,
+                    pointer: `${pointer}/${property}`
+                });
             }
             return undefined;
         });
     },
-    uniqueItems: (core, schema, value, pointer) => {
+    uniqueItems: (core, schema, value: unknown[], pointer) => {
         if ((Array.isArray(value) && schema.uniqueItems) === false) {
             return undefined;
         }
 
-        const errors = [];
+        const errors: JSONError[] = [];
         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;