json-schema-library 5.3.0 → 7.0.0

package/dist/module/lib/utils/flattenArray.js

@@ -1,10 +1,11 @@
 export default function flattenArray(list, result = []) {
     for (let i = 0; i < list.length; i += 1) {
-        if (Array.isArray(list[i])) {
-            flattenArray(list[i], result);
+        const item = list[i];
+        if (Array.isArray(item)) {
+            flattenArray(item, result);
         }
         else {
-            result.push(list[i]);
+            result.push(item);
         }
     }
     return result;

package/dist/module/lib/utils/merge.js

@@ -1,3 +1,7 @@
 import deepmerge from "deepmerge";
+// @ts-ignore
 const overwriteMerge = (destinationArray, sourceArray) => sourceArray;
+/**
+ * returns a new json-schema, where properties are combined and arrays are replaced
+ */
 export default (a, b) => deepmerge(a, b, { arrayMerge: overwriteMerge });

package/dist/module/lib/utils/punycode.ucs2decode.js

@@ -20,12 +20,13 @@ export default function ucs2decode(string) {
     const length = string.length;
     while (counter < length) {
         const value = string.charCodeAt(counter++);
-        if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+        if (value >= 0xd800 && value <= 0xdbff && counter < length) {
             // It's a high surrogate, and there is a next character.
             const extra = string.charCodeAt(counter++);
             // eslint-disable-next-line eqeqeq
-            if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.
-                output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+            if ((extra & 0xfc00) == 0xdc00) {
+                // Low surrogate.
+                output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
             }
             else {
                 // It's an unmatched surrogate; only append this code unit, in case the

package/dist/module/lib/validate.js

@@ -1,11 +1,14 @@
 import getTypeOf from "./getTypeOf";
 import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
+import { isJSONError } from "./types";
+import equal from "fast-deep-equal";
 function getJsonSchemaType(value, expectedType) {
-    let jsType = getTypeOf(value);
-    if (jsType === "number" && (expectedType === "integer" ||
-        (Array.isArray(expectedType) && expectedType.includes("integer")))) {
-        jsType = Number.isInteger(value) ? "integer" : "number";
+    const jsType = getTypeOf(value);
+    if (jsType === "number" &&
+        (expectedType === "integer" ||
+            (Array.isArray(expectedType) && expectedType.includes("integer")))) {
+        return Number.isInteger(value) ? "integer" : "number";
     }
     return jsType;
 }
@@ -19,19 +22,42 @@ function getJsonSchemaType(value, expectedType) {
  * @return list of errors or empty
  */
 export default function validate(core, value, schema = core.rootSchema, pointer = "#") {
-    if (schema.type === "error") {
+    schema = core.resolveRef(schema);
+    // this is a high level v7 schema validation
+    if (getTypeOf(schema) === "boolean") {
+        if (schema) {
+            return [];
+        }
+        return [core.errors.invalidDataError({ value, pointer })];
+    }
+    if (isJSONError(schema)) {
         return [schema];
     }
-    schema = core.resolveRef(schema);
+    // @draft >= 6 const
+    if (schema.const !== undefined) {
+        if (equal(schema.const, value)) {
+            return [];
+        }
+        return [core.errors.constError({ value, expected: schema.const, pointer })];
+    }
     const receivedType = getJsonSchemaType(value, schema.type);
     const expectedType = schema.type || receivedType;
-    if (receivedType !== expectedType && (!Array.isArray(expectedType) || !expectedType.includes(receivedType))) {
-        return [core.errors.typeError({ received: receivedType, expected: expectedType, value, pointer })];
+    if (receivedType !== expectedType &&
+        (!Array.isArray(expectedType) || !expectedType.includes(receivedType))) {
+        return [
+            core.errors.typeError({
+                received: receivedType,
+                expected: expectedType,
+                value,
+                pointer
+            })
+        ];
     }
     if (core.validateType[receivedType] == null) {
         return [core.errors.invalidTypeError({ receivedType, pointer })];
     }
     const errors = flattenArray(core.validateType[receivedType](core, schema, value, pointer));
     // also promises may be passed along (validateAsync)
+    // @ts-ignore
     return errors.filter(errorOrPromise);
 }

package/dist/module/lib/validateAsync.js

@@ -1,5 +1,6 @@
-import { isError, errorsOnly } from "./utils/filter";
+import { errorsOnly } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
+import { isJSONError } from "./types";
 function createErrorNotification(onError) {
     return function notifyError(error) {
         if (Array.isArray(error)) {
@@ -7,7 +8,7 @@ function createErrorNotification(onError) {
             error.forEach(notifyError);
             return error;
         }
-        if (isError(error)) {
+        if (isJSONError(error)) {
             onError(error);
         }
         return error;
@@ -35,16 +36,15 @@ export default function validateAsync(core, value, options) {
             if (errors[i] instanceof Promise) {
                 errors[i].then(notifyError);
             }
-            else if (isError(errors[i])) {
+            else if (isJSONError(errors[i])) {
                 onError(errors[i]);
             }
         }
     }
-    return Promise
-        .all(errors)
+    return Promise.all(errors)
         .then(flattenArray)
-        .then(resolvedErrors => resolvedErrors.filter(errorsOnly))
-        .catch(e => {
+        .then((resolvedErrors) => resolvedErrors.filter(errorsOnly))
+        .catch((e) => {
         console.log("Failed resolving promises", e.message);
         console.log(e.stack);
         throw e;

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

@@ -1,21 +1,34 @@
 /* eslint no-invalid-this: 0 */
-import createCustomError from "../utils/createCustomError";
+import { createCustomError } from "../utils/createCustomError";
 const errors = {
     additionalItemsError: createCustomError("AdditionalItemsError"),
     additionalPropertiesError: createCustomError("AdditionalPropertiesError"),
     anyOfError: createCustomError("AnyOfError"),
     allOfError: createCustomError("AllOfError"),
+    constError: createCustomError("ConstError"),
+    containsError: createCustomError("ContainsError"),
+    containsArrayError: createCustomError("ContainsArrayError"),
+    containsAnyError: createCustomError("ContainsAnyError"),
     enumError: createCustomError("EnumError"),
-    formatUrlError: createCustomError("FormatUrlError"),
-    formatUriError: createCustomError("FormatUriError"),
+    formatURLError: createCustomError("FormatURLError"),
+    formatURIError: createCustomError("FormatURIError"),
+    formatURIReferenceError: createCustomError("FormatURIReferenceError"),
+    formatURITemplateError: createCustomError("FormatURITemplateError"),
+    formatDateError: createCustomError("FormatDateaError"),
     formatDateTimeError: createCustomError("FormatDateTimeError"),
     formatEmailError: createCustomError("FormatEmailError"),
     formatHostnameError: createCustomError("FormatHostnameError"),
     formatIPV4Error: createCustomError("FormatIPV4Error"),
+    formatIPV4LeadingZeroError: createCustomError("FormatIPV4LeadingZeroError"),
     formatIPV6Error: createCustomError("FormatIPV6Error"),
+    formatIPV6LeadingZeroError: createCustomError("FormatIPV6LeadingZeroError"),
+    formatJSONPointerError: createCustomError("FormatJSONPointerError"),
     formatRegExError: createCustomError("FormatRegExError"),
+    formatTimeError: createCustomError("FormatTimeError"),
     invalidSchemaError: createCustomError("InvalidSchemaError"),
+    invalidDataError: createCustomError("InvalidDataError"),
     invalidTypeError: createCustomError("InvalidTypeError"),
+    invalidPropertyNameError: createCustomError("InvalidPropertyNameError"),
     maximumError: createCustomError("MaximumError"),
     maxItemsError: createCustomError("MaxItemsError"),
     maxLengthError: createCustomError("MaxLengthError"),

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

@@ -1,13 +1,46 @@
-/* eslint-disable max-len */
+/* eslint-disable max-len, no-control-regex */
 import errors from "./errors";
 import validUrl from "valid-url";
+// referenced
+// https://github.com/cfworker/cfworker/blob/main/packages/json-schema/src/format.ts
 // https://gist.github.com/marcelotmelo/b67f58a08bee6c2468f8
 const isValidDateTime = new RegExp("^([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])[Tt]([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\\.[0-9]+)?(([Zz])|([\\+|\\-]([01][0-9]|2[0-3]):[0-5][0-9]))$");
 const isValidIPV4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
 const isValidIPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
 const isValidHostname = /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/;
+const matchDate = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+const matchTime = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const isValidJSONPointer = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
+const isValidRelativeJSONPointer = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+const isValidURIRef = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+// uri-template: https://tools.ietf.org/html/rfc6570
+const isValidURITemplate = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
 // Default JSON-Schema formats: date-time, email, hostname, ipv4, ipv6, uri, uriref
-export default {
+const formatValidators = {
+    date: (core, schema, value, pointer) => {
+        if (typeof value !== "string") {
+            return undefined;
+        }
+        // https://github.com/cfworker/cfworker/blob/main/packages/json-schema/src/format.ts
+        // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
+        const matches = value.match(matchDate);
+        if (!matches) {
+            return errors.formatDateTimeError({ value, pointer });
+        }
+        const year = +matches[1];
+        const month = +matches[2];
+        const day = +matches[3];
+        // https://tools.ietf.org/html/rfc3339#appendix-C
+        const isLeapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+        if (month >= 1 &&
+            month <= 12 &&
+            day >= 1 &&
+            day <= (month == 2 && isLeapYear ? 29 : DAYS[month])) {
+            return undefined;
+        }
+        return errors.formatDateError({ value, pointer });
+    },
     "date-time": (core, schema, value, pointer) => {
         if (typeof value !== "string") {
             return undefined;
@@ -28,17 +61,17 @@ export default {
         if (value[0] === '"') {
             return errors.formatEmailError({ value, pointer });
         }
-        const [name, host, ...rest] = value.split('@');
+        const [name, host, ...rest] = value.split("@");
         if (!name || !host || rest.length !== 0 || name.length > 64 || host.length > 253) {
             return errors.formatEmailError({ value, pointer });
         }
-        if (name[0] === '.' || name.endsWith('.') || name.includes('..')) {
+        if (name[0] === "." || name.endsWith(".") || name.includes("..")) {
             return errors.formatEmailError({ value, pointer });
         }
         if (!/^[a-z0-9.-]+$/i.test(host) || !/^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+$/i.test(name)) {
             return errors.formatEmailError({ value, pointer });
         }
-        if (!host.split('.').every(part => /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(part))) {
+        if (!host.split(".").every((part) => /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(part))) {
             return errors.formatEmailError({ value, pointer });
         }
         return undefined;
@@ -56,6 +89,10 @@ export default {
         if (typeof value !== "string" || value === "") {
             return undefined;
         }
+        if (value && value[0] === "0") {
+            // leading zeroes should be rejected, as they are treated as octals
+            return errors.formatIPV4LeadingZeroError({ value, pointer });
+        }
         if (value.length <= 15 && isValidIPV4.test(value)) {
             return undefined;
         }
@@ -65,25 +102,94 @@ export default {
         if (typeof value !== "string" || value === "") {
             return undefined;
         }
+        if (value && value[0] === "0") {
+            // leading zeroes should be rejected, as they are treated as octals
+            return errors.formatIPV6LeadingZeroError({ value, pointer });
+        }
         if (value.length <= 45 && isValidIPV6.test(value)) {
             return undefined;
         }
         return errors.formatIPV6Error({ value, pointer });
     },
+    "json-pointer": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidJSONPointer.test(value)) {
+            return undefined;
+        }
+        return errors.formatJSONPointerError({ value, pointer });
+    },
+    "relative-json-pointer": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidRelativeJSONPointer.test(value)) {
+            return undefined;
+        }
+        return errors.formatJSONPointerError({ value, pointer });
+    },
     regex: (core, schema, value, pointer) => {
         if (typeof value === "string" && /\\Z$/.test(value) === false) {
+            try {
+                new RegExp(value);
+                return undefined;
+            }
+            catch (e) { } // eslint-disable-line no-empty
+            return errors.formatRegExError({ value, pointer });
+        }
+        // v7 tests, ignore non-regex values
+        if (typeof value === "object" || typeof value === "number" || Array.isArray(value)) {
             return undefined;
         }
         return errors.formatRegExError({ value, pointer });
     },
-    uri: (core, schema, value, pointer) => {
+    time: (core, schema, value, pointer) => {
         if (typeof value !== "string") {
             return undefined;
         }
-        if (value === "" || validUrl.isUri(value)) {
+        // https://github.com/cfworker/cfworker/blob/main/packages/json-schema/src/format.ts
+        const matches = value.match(matchTime);
+        if (!matches) {
+            return errors.formatDateTimeError({ value, pointer });
+        }
+        const hour = +matches[1];
+        const minute = +matches[2];
+        const second = +matches[3];
+        const timeZone = !!matches[5];
+        if (((hour <= 23 && minute <= 59 && second <= 59) ||
+            (hour == 23 && minute == 59 && second == 60)) &&
+            timeZone) {
+            return undefined;
+        }
+        return errors.formatTimeError({ value, pointer });
+    },
+    uri: (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (validUrl.isUri(value)) {
+            return undefined;
+        }
+        return errors.formatURIError({ value, pointer });
+    },
+    "uri-reference": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidURIRef.test(value)) {
+            return undefined;
+        }
+        return errors.formatURIReferenceError({ value, pointer });
+    },
+    "uri-template": (core, schema, value, pointer) => {
+        if (typeof value !== "string" || value === "") {
+            return undefined;
+        }
+        if (isValidURITemplate.test(value)) {
             return undefined;
         }
-        return errors.formatUriError({ value, pointer });
+        return errors.formatURITemplateError({ value, pointer });
     },
     url: (core, schema, value, pointer) => {
         if (value === "" || validUrl.isWebUri(value)) {
@@ -92,3 +198,4 @@ export default {
         return errors.formatUrlError({ value, pointer });
     }
 };
+export default formatValidators;

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],
@@ -48,12 +52,13 @@ const KeywordValidation = {
                         }));
                     }
                     else {
-                        errors.push(core.validate(value[property], result, pointer));
+                        errors.push(...core.validate(value[property], result, pointer));
                     }
                     // 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,8 +83,8 @@ const KeywordValidation = {
             return undefined;
         }
         const errors = [];
-        schema.allOf.forEach(subSchema => {
-            errors.push(core.validate(value, subSchema, pointer));
+        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;
         });