z-schema 6.0.2 → 7.0.0-beta.1

package/dist/SchemaValidation.js

@@ -0,0 +1,631 @@
+import { FormatValidators } from './FormatValidators.js';
+import * as JsonValidation from './JsonValidation.js';
+import { Report } from './Report.js';
+import * as Utils from './Utils.js';
+const SchemaValidators = {
+    $ref: function (report, schema) {
+        // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
+        // http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03
+        if (typeof schema.$ref !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['$ref', 'string']);
+        }
+    },
+    $schema: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-core.html#rfc.section.6
+        if (typeof schema.$schema !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['$schema', 'string']);
+        }
+    },
+    multipleOf: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.1
+        if (typeof schema.multipleOf !== 'number') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['multipleOf', 'number']);
+        }
+        else if (schema.multipleOf <= 0) {
+            report.addError('KEYWORD_MUST_BE', ['multipleOf', 'strictly greater than 0']);
+        }
+    },
+    maximum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
+        if (typeof schema.maximum !== 'number') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['maximum', 'number']);
+        }
+    },
+    exclusiveMaximum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
+        if (typeof schema.exclusiveMaximum !== 'boolean') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['exclusiveMaximum', 'boolean']);
+        }
+        else if (schema.maximum === undefined) {
+            report.addError('KEYWORD_DEPENDENCY', ['exclusiveMaximum', 'maximum']);
+        }
+    },
+    minimum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.1
+        if (typeof schema.minimum !== 'number') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['minimum', 'number']);
+        }
+    },
+    exclusiveMinimum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.1
+        if (typeof schema.exclusiveMinimum !== 'boolean') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['exclusiveMinimum', 'boolean']);
+        }
+        else if (schema.minimum === undefined) {
+            report.addError('KEYWORD_DEPENDENCY', ['exclusiveMinimum', 'minimum']);
+        }
+    },
+    maxLength: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.1
+        if (Utils.whatIs(schema.maxLength) !== 'integer') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['maxLength', 'integer']);
+        }
+        else if (schema.maxLength < 0) {
+            report.addError('KEYWORD_MUST_BE', ['maxLength', 'greater than, or equal to 0']);
+        }
+    },
+    minLength: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.1
+        if (Utils.whatIs(schema.minLength) !== 'integer') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['minLength', 'integer']);
+        }
+        else if (schema.minLength < 0) {
+            report.addError('KEYWORD_MUST_BE', ['minLength', 'greater than, or equal to 0']);
+        }
+    },
+    pattern: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3.1
+        if (typeof schema.pattern !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['pattern', 'string']);
+        }
+        else {
+            try {
+                RegExp(schema.pattern);
+            }
+            catch (_e) {
+                report.addError('KEYWORD_PATTERN', ['pattern', schema.pattern]);
+            }
+        }
+    },
+    additionalItems: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
+        const type = Utils.whatIs(schema.additionalItems);
+        if (type !== 'boolean' && type !== 'object') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['additionalItems', ['boolean', 'object']]);
+        }
+        else if (type === 'object') {
+            report.path.push('additionalItems');
+            validateSchema.call(this, report, schema.additionalItems);
+            report.path.pop();
+        }
+    },
+    items: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
+        const type = Utils.whatIs(schema.items);
+        if (type === 'object') {
+            report.path.push('items');
+            validateSchema.call(this, report, schema.items);
+            report.path.pop();
+        }
+        else if (type === 'array') {
+            let idx = schema.items.length;
+            while (idx--) {
+                report.path.push('items');
+                report.path.push(idx.toString());
+                validateSchema.call(this, report, schema.items[idx]);
+                report.path.pop();
+                report.path.pop();
+            }
+        }
+        else {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['items', ['array', 'object']]);
+        }
+        // custom - strict mode
+        if (this.options.forceAdditional === true && schema.additionalItems === undefined && Array.isArray(schema.items)) {
+            report.addError('KEYWORD_UNDEFINED_STRICT', ['additionalItems']);
+        }
+        // custome - assume defined false mode
+        if (this.options.assumeAdditional && schema.additionalItems === undefined && Array.isArray(schema.items)) {
+            schema.additionalItems = false;
+        }
+    },
+    maxItems: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.2.1
+        if (typeof schema.maxItems !== 'number') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['maxItems', 'integer']);
+        }
+        else if (schema.maxItems < 0) {
+            report.addError('KEYWORD_MUST_BE', ['maxItems', 'greater than, or equal to 0']);
+        }
+    },
+    minItems: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.3.1
+        if (Utils.whatIs(schema.minItems) !== 'integer') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['minItems', 'integer']);
+        }
+        else if (schema.minItems < 0) {
+            report.addError('KEYWORD_MUST_BE', ['minItems', 'greater than, or equal to 0']);
+        }
+    },
+    uniqueItems: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.4.1
+        if (typeof schema.uniqueItems !== 'boolean') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['uniqueItems', 'boolean']);
+        }
+    },
+    maxProperties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.1.1
+        if (Utils.whatIs(schema.maxProperties) !== 'integer') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['maxProperties', 'integer']);
+        }
+        else if (schema.maxProperties < 0) {
+            report.addError('KEYWORD_MUST_BE', ['maxProperties', 'greater than, or equal to 0']);
+        }
+    },
+    minProperties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.2.1
+        if (Utils.whatIs(schema.minProperties) !== 'integer') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['minProperties', 'integer']);
+        }
+        else if (schema.minProperties < 0) {
+            report.addError('KEYWORD_MUST_BE', ['minProperties', 'greater than, or equal to 0']);
+        }
+    },
+    required: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.3.1
+        if (Utils.whatIs(schema.required) !== 'array') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['required', 'array']);
+        }
+        else if (schema.required.length === 0) {
+            report.addError('KEYWORD_MUST_BE', ['required', 'an array with at least one element']);
+        }
+        else {
+            let idx = schema.required.length;
+            while (idx--) {
+                if (typeof schema.required[idx] !== 'string') {
+                    report.addError('KEYWORD_VALUE_TYPE', ['required', 'string']);
+                }
+            }
+            if (Utils.isUniqueArray(schema.required) === false) {
+                report.addError('KEYWORD_MUST_BE', ['required', 'an array with unique items']);
+            }
+        }
+    },
+    additionalProperties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
+        const type = Utils.whatIs(schema.additionalProperties);
+        if (type !== 'boolean' && type !== 'object') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['additionalProperties', ['boolean', 'object']]);
+        }
+        else if (type === 'object') {
+            report.path.push('additionalProperties');
+            validateSchema.call(this, report, schema.additionalProperties);
+            report.path.pop();
+        }
+    },
+    properties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
+        if (Utils.whatIs(schema.properties) !== 'object') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['properties', 'object']);
+            return;
+        }
+        const keys = Object.keys(schema.properties);
+        let idx = keys.length;
+        while (idx--) {
+            const key = keys[idx], val = schema.properties[key];
+            report.path.push('properties');
+            report.path.push(key);
+            validateSchema.call(this, report, val);
+            report.path.pop();
+            report.path.pop();
+        }
+        // custom - strict mode
+        if (this.options.forceAdditional === true && schema.additionalProperties === undefined) {
+            report.addError('KEYWORD_UNDEFINED_STRICT', ['additionalProperties']);
+        }
+        // custome - assume defined false mode
+        if (this.options.assumeAdditional && schema.additionalProperties === undefined) {
+            schema.additionalProperties = false;
+        }
+        // custom - forceProperties
+        if (this.options.forceProperties === true && keys.length === 0) {
+            report.addError('CUSTOM_MODE_FORCE_PROPERTIES', ['properties']);
+        }
+    },
+    patternProperties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
+        if (Utils.whatIs(schema.patternProperties) !== 'object') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['patternProperties', 'object']);
+            return;
+        }
+        const keys = Object.keys(schema.patternProperties);
+        let idx = keys.length;
+        while (idx--) {
+            const key = keys[idx], val = schema.patternProperties[key];
+            try {
+                RegExp(key);
+            }
+            catch (_e) {
+                report.addError('KEYWORD_PATTERN', ['patternProperties', key]);
+            }
+            report.path.push('patternProperties');
+            report.path.push(key.toString());
+            validateSchema.call(this, report, val);
+            report.path.pop();
+            report.path.pop();
+        }
+        // custom - forceProperties
+        if (this.options.forceProperties === true && keys.length === 0) {
+            report.addError('CUSTOM_MODE_FORCE_PROPERTIES', ['patternProperties']);
+        }
+    },
+    dependencies: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.5.1
+        if (Utils.whatIs(schema.dependencies) !== 'object') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['dependencies', 'object']);
+        }
+        else {
+            const keys = Object.keys(schema.dependencies);
+            let idx = keys.length;
+            while (idx--) {
+                const schemaKey = keys[idx], schemaDependency = schema.dependencies[schemaKey], type = Utils.whatIs(schemaDependency);
+                if (type === 'object') {
+                    report.path.push('dependencies');
+                    report.path.push(schemaKey);
+                    validateSchema.call(this, report, schemaDependency);
+                    report.path.pop();
+                    report.path.pop();
+                }
+                else if (type === 'array') {
+                    let idx2 = schemaDependency.length;
+                    if (idx2 === 0) {
+                        report.addError('KEYWORD_MUST_BE', ['dependencies', 'not empty array']);
+                    }
+                    while (idx2--) {
+                        if (typeof schemaDependency[idx2] !== 'string') {
+                            report.addError('KEYWORD_VALUE_TYPE', ['dependensices', 'string']);
+                        }
+                    }
+                    if (Utils.isUniqueArray(schemaDependency) === false) {
+                        report.addError('KEYWORD_MUST_BE', ['dependencies', 'an array with unique items']);
+                    }
+                }
+                else {
+                    report.addError('KEYWORD_VALUE_TYPE', ['dependencies', 'object or array']);
+                }
+            }
+        }
+    },
+    enum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.1
+        if (Array.isArray(schema.enum) === false) {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['enum', 'array']);
+        }
+        else if (schema.enum.length === 0) {
+            report.addError('KEYWORD_MUST_BE', ['enum', 'an array with at least one element']);
+        }
+        else if (Utils.isUniqueArray(schema.enum) === false) {
+            report.addError('KEYWORD_MUST_BE', ['enum', 'an array with unique elements']);
+        }
+    },
+    type: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.1
+        const primitiveTypes = ['array', 'boolean', 'integer', 'number', 'null', 'object', 'string'], primitiveTypeStr = primitiveTypes.join(','), isArray = Array.isArray(schema.type);
+        if (isArray) {
+            let idx = schema.type.length;
+            while (idx--) {
+                if (primitiveTypes.indexOf(schema.type[idx]) === -1) {
+                    report.addError('KEYWORD_TYPE_EXPECTED', ['type', primitiveTypeStr]);
+                }
+            }
+            if (Utils.isUniqueArray(schema.type) === false) {
+                report.addError('KEYWORD_MUST_BE', ['type', 'an object with unique properties']);
+            }
+        }
+        else if (typeof schema.type === 'string') {
+            if (primitiveTypes.indexOf(schema.type) === -1) {
+                report.addError('KEYWORD_TYPE_EXPECTED', ['type', primitiveTypeStr]);
+            }
+        }
+        else {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['type', ['string', 'array']]);
+        }
+        if (this.options.noEmptyStrings === true) {
+            if (schema.type === 'string' || (isArray && schema.type.indexOf('string') !== -1)) {
+                if (schema.minLength === undefined && schema.enum === undefined && schema.format === undefined) {
+                    schema.minLength = 1;
+                }
+            }
+        }
+        if (this.options.noEmptyArrays === true) {
+            if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+                if (schema.minItems === undefined) {
+                    schema.minItems = 1;
+                }
+            }
+        }
+        if (this.options.forceProperties === true) {
+            if (schema.type === 'object' || (isArray && schema.type.indexOf('object') !== -1)) {
+                if (schema.properties === undefined && schema.patternProperties === undefined) {
+                    report.addError('KEYWORD_UNDEFINED_STRICT', ['properties']);
+                }
+            }
+        }
+        if (this.options.forceItems === true) {
+            if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+                if (schema.items === undefined) {
+                    report.addError('KEYWORD_UNDEFINED_STRICT', ['items']);
+                }
+            }
+        }
+        if (this.options.forceMinItems === true) {
+            if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+                if (schema.minItems === undefined) {
+                    report.addError('KEYWORD_UNDEFINED_STRICT', ['minItems']);
+                }
+            }
+        }
+        if (this.options.forceMaxItems === true) {
+            if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+                if (schema.maxItems === undefined) {
+                    report.addError('KEYWORD_UNDEFINED_STRICT', ['maxItems']);
+                }
+            }
+        }
+        if (this.options.forceMinLength === true) {
+            if (schema.type === 'string' || (isArray && schema.type.indexOf('string') !== -1)) {
+                if (schema.minLength === undefined &&
+                    schema.format === undefined &&
+                    schema.enum === undefined &&
+                    schema.pattern === undefined) {
+                    report.addError('KEYWORD_UNDEFINED_STRICT', ['minLength']);
+                }
+            }
+        }
+        if (this.options.forceMaxLength === true) {
+            if (schema.type === 'string' || (isArray && schema.type.indexOf('string') !== -1)) {
+                if (schema.maxLength === undefined &&
+                    schema.format === undefined &&
+                    schema.enum === undefined &&
+                    schema.pattern === undefined) {
+                    report.addError('KEYWORD_UNDEFINED_STRICT', ['maxLength']);
+                }
+            }
+        }
+    },
+    allOf: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.3.1
+        if (Array.isArray(schema.allOf) === false) {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['allOf', 'array']);
+        }
+        else if (schema.allOf.length === 0) {
+            report.addError('KEYWORD_MUST_BE', ['allOf', 'an array with at least one element']);
+        }
+        else {
+            let idx = schema.allOf.length;
+            while (idx--) {
+                report.path.push('allOf');
+                report.path.push(idx.toString());
+                validateSchema.call(this, report, schema.allOf[idx]);
+                report.path.pop();
+                report.path.pop();
+            }
+        }
+    },
+    anyOf: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.1
+        if (Array.isArray(schema.anyOf) === false) {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['anyOf', 'array']);
+        }
+        else if (schema.anyOf.length === 0) {
+            report.addError('KEYWORD_MUST_BE', ['anyOf', 'an array with at least one element']);
+        }
+        else {
+            let idx = schema.anyOf.length;
+            while (idx--) {
+                report.path.push('anyOf');
+                report.path.push(idx.toString());
+                validateSchema.call(this, report, schema.anyOf[idx]);
+                report.path.pop();
+                report.path.pop();
+            }
+        }
+    },
+    oneOf: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.1
+        if (Array.isArray(schema.oneOf) === false) {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['oneOf', 'array']);
+        }
+        else if (schema.oneOf.length === 0) {
+            report.addError('KEYWORD_MUST_BE', ['oneOf', 'an array with at least one element']);
+        }
+        else {
+            let idx = schema.oneOf.length;
+            while (idx--) {
+                report.path.push('oneOf');
+                report.path.push(idx.toString());
+                validateSchema.call(this, report, schema.oneOf[idx]);
+                report.path.pop();
+                report.path.pop();
+            }
+        }
+    },
+    not: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.1
+        if (Utils.whatIs(schema.not) !== 'object') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['not', 'object']);
+        }
+        else {
+            report.path.push('not');
+            validateSchema.call(this, report, schema.not);
+            report.path.pop();
+        }
+    },
+    definitions: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.1
+        if (Utils.whatIs(schema.definitions) !== 'object') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['definitions', 'object']);
+        }
+        else {
+            const keys = Object.keys(schema.definitions);
+            let idx = keys.length;
+            while (idx--) {
+                const key = keys[idx], val = schema.definitions[key];
+                report.path.push('definitions');
+                report.path.push(key);
+                validateSchema.call(this, report, val);
+                report.path.pop();
+                report.path.pop();
+            }
+        }
+    },
+    format: function (report, schema) {
+        if (typeof schema.format !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['format', 'string']);
+        }
+        else {
+            if (FormatValidators[schema.format] === undefined && this.options.ignoreUnknownFormats !== true) {
+                report.addError('UNKNOWN_FORMAT', [schema.format]);
+            }
+        }
+    },
+    id: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-core.html#rfc.section.7.2
+        if (typeof schema.id !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['id', 'string']);
+        }
+    },
+    title: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1
+        if (typeof schema.title !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['title', 'string']);
+        }
+    },
+    description: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1
+        if (typeof schema.description !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['description', 'string']);
+        }
+    },
+    default: function ( /* report, schema */) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.2
+        // There are no restrictions placed on the value of this keyword.
+    },
+};
+/**
+ *
+ * @param {Report} report
+ * @param {*[]} arr
+ *
+ * @returns {boolean}
+ */
+const validateArrayOfSchemas = function (report, arr) {
+    let idx = arr.length;
+    while (idx--) {
+        validateSchema.call(this, report, arr[idx]);
+    }
+    return report.isValid();
+};
+/**
+ *
+ * @param {Report} report
+ * @param {*} schema
+ */
+export function validateSchema(report, schema) {
+    report.commonErrorMessage = 'SCHEMA_VALIDATION_FAILED';
+    // if schema is an array, assume it's an array of schemas
+    if (Array.isArray(schema)) {
+        return validateArrayOfSchemas.call(this, report, schema);
+    }
+    // do not revalidate schema that has already been validated once
+    if (schema.__$validated) {
+        return true;
+    }
+    // if $schema is present, this schema should validate against that $schema
+    const hasParentSchema = schema.$schema && schema.id !== schema.$schema;
+    if (hasParentSchema) {
+        if (schema.__$schemaResolved && schema.__$schemaResolved !== schema) {
+            const subReport = new Report(report);
+            const valid = JsonValidation.validate.call(this, subReport, schema.__$schemaResolved, schema);
+            if (valid === false) {
+                report.addError('PARENT_SCHEMA_VALIDATION_FAILED', null, subReport);
+            }
+        }
+        else {
+            if (this.options.ignoreUnresolvableReferences !== true) {
+                report.addError('REF_UNRESOLVED', [schema.$schema]);
+            }
+        }
+    }
+    if (this.options.noTypeless === true) {
+        // issue #36 - inherit type to anyOf, oneOf, allOf if noTypeless is defined
+        if (schema.type !== undefined) {
+            let schemas = [];
+            if (Array.isArray(schema.anyOf)) {
+                schemas = schemas.concat(schema.anyOf);
+            }
+            if (Array.isArray(schema.oneOf)) {
+                schemas = schemas.concat(schema.oneOf);
+            }
+            if (Array.isArray(schema.allOf)) {
+                schemas = schemas.concat(schema.allOf);
+            }
+            schemas.forEach(function (sch) {
+                if (!sch.type) {
+                    sch.type = schema.type;
+                }
+            });
+        }
+        // end issue #36
+        if (schema.enum === undefined &&
+            schema.type === undefined &&
+            schema.anyOf === undefined &&
+            schema.oneOf === undefined &&
+            schema.not === undefined &&
+            schema.$ref === undefined) {
+            report.addError('KEYWORD_UNDEFINED_STRICT', ['type']);
+        }
+    }
+    const keys = Object.keys(schema);
+    let idx = keys.length;
+    while (idx--) {
+        const key = keys[idx];
+        if (key.indexOf('__') === 0) {
+            continue;
+        }
+        if (SchemaValidators[key] !== undefined) {
+            SchemaValidators[key].call(this, report, schema);
+        }
+        else if (!hasParentSchema) {
+            if (this.options.noExtraKeywords === true) {
+                report.addError('KEYWORD_UNEXPECTED', [key]);
+            }
+        }
+    }
+    if (this.options.pedanticCheck === true) {
+        if (schema.enum) {
+            // break recursion
+            const tmpSchema = Utils.clone(schema);
+            delete tmpSchema.enum;
+            delete tmpSchema.default;
+            report.path.push('enum');
+            idx = schema.enum.length;
+            while (idx--) {
+                report.path.push(idx.toString());
+                JsonValidation.validate.call(this, report, tmpSchema, schema.enum[idx]);
+                report.path.pop();
+            }
+            report.path.pop();
+        }
+        if (schema.default) {
+            report.path.push('default');
+            JsonValidation.validate.call(this, report, schema, schema.default);
+            report.path.pop();
+        }
+    }
+    const isValid = report.isValid();
+    if (isValid) {
+        schema.__$validated = true;
+    }
+    return isValid;
+}