z-schema 7.0.0 → 7.0.6

package/dist/{JsonValidation.js → json-validation.js}

@@ -1,6 +1,10 @@
-import { FormatValidators } from './FormatValidators.js';
-import { Report } from './Report.js';
-import * as Utils from './Utils.js';
+import { Report } from './report.js';
+import { isObject, whatIs } from './utils/what-is.js';
+import { ucs2decode } from './utils/unicode.js';
+import { difference, isUniqueArray } from './utils/array.js';
+import { areEqual } from './utils/json.js';
+import { shallowClone } from './utils/clone.js';
+import { getFormatValidators } from './format-validators.js';
 const shouldSkipValidate = function (options, errors) {
     return (options &&
         Array.isArray(options.includeErrors) &&
@@ -10,6 +14,12 @@ const shouldSkipValidate = function (options, errors) {
         }));
 };
 export const JsonValidators = {
+    id: () => { },
+    $ref: () => { },
+    $schema: () => { },
+    title: () => { },
+    description: () => { },
+    default: () => { },
     multipleOf: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.2
         if (shouldSkipValidate(this.validateOptions, ['MULTIPLE_OF'])) {
@@ -20,8 +30,8 @@ export const JsonValidators = {
         }
         const stringMultipleOf = String(schema.multipleOf);
         const scale = Math.pow(10, stringMultipleOf.length - stringMultipleOf.indexOf('.') - 1);
-        if (Utils.whatIs((json * scale) / (schema.multipleOf * scale)) !== 'integer') {
-            report.addError('MULTIPLE_OF', [json, schema.multipleOf], null, schema);
+        if (whatIs((json * scale) / (schema.multipleOf * scale)) !== 'integer') {
+            report.addError('MULTIPLE_OF', [json, schema.multipleOf], undefined, schema);
         }
     },
     maximum: function (report, schema, json) {
@@ -34,12 +44,12 @@ export const JsonValidators = {
         }
         if (schema.exclusiveMaximum !== true) {
             if (json > schema.maximum) {
-                report.addError('MAXIMUM', [json, schema.maximum], null, schema);
+                report.addError('MAXIMUM', [json, schema.maximum], undefined, schema);
             }
         }
         else {
             if (json >= schema.maximum) {
-                report.addError('MAXIMUM_EXCLUSIVE', [json, schema.maximum], null, schema);
+                report.addError('MAXIMUM_EXCLUSIVE', [json, schema.maximum], undefined, schema);
             }
         }
     },
@@ -56,12 +66,12 @@ export const JsonValidators = {
         }
         if (schema.exclusiveMinimum !== true) {
             if (json < schema.minimum) {
-                report.addError('MINIMUM', [json, schema.minimum], null, schema);
+                report.addError('MINIMUM', [json, schema.minimum], undefined, schema);
             }
         }
         else {
             if (json <= schema.minimum) {
-                report.addError('MINIMUM_EXCLUSIVE', [json, schema.minimum], null, schema);
+                report.addError('MINIMUM_EXCLUSIVE', [json, schema.minimum], undefined, schema);
             }
         }
     },
@@ -76,8 +86,8 @@ export const JsonValidators = {
         if (typeof json !== 'string') {
             return;
         }
-        if (Utils.ucs2decode(json).length > schema.maxLength) {
-            report.addError('MAX_LENGTH', [json.length, schema.maxLength], null, schema);
+        if (ucs2decode(json).length > schema.maxLength) {
+            report.addError('MAX_LENGTH', [json.length, schema.maxLength], undefined, schema);
         }
     },
     minLength: function (report, schema, json) {
@@ -88,8 +98,8 @@ export const JsonValidators = {
         if (typeof json !== 'string') {
             return;
         }
-        if (Utils.ucs2decode(json).length < schema.minLength) {
-            report.addError('MIN_LENGTH', [json.length, schema.minLength], null, schema);
+        if (ucs2decode(json).length < schema.minLength) {
+            report.addError('MIN_LENGTH', [json.length, schema.minLength], undefined, schema);
         }
     },
     pattern: function (report, schema, json) {
@@ -101,7 +111,7 @@ export const JsonValidators = {
             return;
         }
         if (RegExp(schema.pattern).test(json) === false) {
-            report.addError('PATTERN', [schema.pattern, json], null, schema);
+            report.addError('PATTERN', [schema.pattern, json], undefined, schema);
         }
     },
     additionalItems: function (report, schema, json) {
@@ -116,12 +126,12 @@ export const JsonValidators = {
         // the json is valid if its size is less than, or equal to, the size of "items".
         if (schema.additionalItems === false && Array.isArray(schema.items)) {
             if (json.length > schema.items.length) {
-                report.addError('ARRAY_ADDITIONAL_ITEMS', null, null, schema);
+                report.addError('ARRAY_ADDITIONAL_ITEMS', undefined, undefined, schema);
             }
         }
     },
     items: function () {
-        /*report, schema, json*/
+        /*report: Report, schema: JsonSchemaInternal, json: unknown*/
         // covered in additionalItems
     },
     maxItems: function (report, schema, json) {
@@ -133,7 +143,7 @@ export const JsonValidators = {
             return;
         }
         if (json.length > schema.maxItems) {
-            report.addError('ARRAY_LENGTH_LONG', [json.length, schema.maxItems], null, schema);
+            report.addError('ARRAY_LENGTH_LONG', [json.length, schema.maxItems], undefined, schema);
         }
     },
     minItems: function (report, schema, json) {
@@ -145,7 +155,7 @@ export const JsonValidators = {
             return;
         }
         if (json.length < schema.minItems) {
-            report.addError('ARRAY_LENGTH_SHORT', [json.length, schema.minItems], null, schema);
+            report.addError('ARRAY_LENGTH_SHORT', [json.length, schema.minItems], undefined, schema);
         }
     },
     uniqueItems: function (report, schema, json) {
@@ -158,8 +168,8 @@ export const JsonValidators = {
         }
         if (schema.uniqueItems === true) {
             const matches = [];
-            if (Utils.isUniqueArray(json, matches) === false) {
-                report.addError('ARRAY_UNIQUE', matches, null, schema);
+            if (isUniqueArray(json, matches) === false) {
+                report.addError('ARRAY_UNIQUE', matches, undefined, schema);
             }
         }
     },
@@ -168,12 +178,12 @@ export const JsonValidators = {
         if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MAXIMUM'])) {
             return;
         }
-        if (Utils.whatIs(json) !== 'object') {
+        if (!isObject(json)) {
             return;
         }
         const keysCount = Object.keys(json).length;
         if (keysCount > schema.maxProperties) {
-            report.addError('OBJECT_PROPERTIES_MAXIMUM', [keysCount, schema.maxProperties], null, schema);
+            report.addError('OBJECT_PROPERTIES_MAXIMUM', [keysCount, schema.maxProperties], undefined, schema);
         }
     },
     minProperties: function (report, schema, json) {
@@ -181,12 +191,12 @@ export const JsonValidators = {
         if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MINIMUM'])) {
             return;
         }
-        if (Utils.whatIs(json) !== 'object') {
+        if (!isObject(json)) {
             return;
         }
         const keysCount = Object.keys(json).length;
         if (keysCount < schema.minProperties) {
-            report.addError('OBJECT_PROPERTIES_MINIMUM', [keysCount, schema.minProperties], null, schema);
+            report.addError('OBJECT_PROPERTIES_MINIMUM', [keysCount, schema.minProperties], undefined, schema);
         }
     },
     required: function (report, schema, json) {
@@ -194,14 +204,14 @@ export const JsonValidators = {
         if (shouldSkipValidate(this.validateOptions, ['OBJECT_MISSING_REQUIRED_PROPERTY'])) {
             return;
         }
-        if (Utils.whatIs(json) !== 'object') {
+        if (!isObject(json)) {
             return;
         }
         let idx = schema.required.length;
         while (idx--) {
             const requiredPropertyName = schema.required[idx];
             if (json[requiredPropertyName] === undefined) {
-                report.addError('OBJECT_MISSING_REQUIRED_PROPERTY', [requiredPropertyName], null, schema);
+                report.addError('OBJECT_MISSING_REQUIRED_PROPERTY', [requiredPropertyName], undefined, schema);
             }
         }
     },
@@ -222,7 +232,7 @@ export const JsonValidators = {
         if (shouldSkipValidate(this.validateOptions, ['OBJECT_ADDITIONAL_PROPERTIES'])) {
             return;
         }
-        if (Utils.whatIs(json) !== 'object') {
+        if (!isObject(json)) {
             return;
         }
         const properties = schema.properties !== undefined ? schema.properties : {};
@@ -235,7 +245,7 @@ export const JsonValidators = {
             // The property set from "patternProperties".
             const pp = Object.keys(patternProperties);
             // remove from "s" all elements of "p", if any;
-            s = Utils.difference(s, p);
+            s = difference(s, p);
             // for each regex in "pp", remove all elements of "s" which this regex matches.
             let idx = pp.length;
             while (idx--) {
@@ -250,19 +260,21 @@ export const JsonValidators = {
             // Validation of the json succeeds if, after these two steps, set "s" is empty.
             if (s.length > 0) {
                 // assumeAdditional can be an array of allowed properties
-                let idx3 = this.options.assumeAdditional.length;
-                if (idx3) {
-                    while (idx3--) {
-                        const io = s.indexOf(this.options.assumeAdditional[idx3]);
-                        if (io !== -1) {
-                            s.splice(io, 1);
+                if (Array.isArray(this.options.assumeAdditional)) {
+                    let idx3 = this.options.assumeAdditional.length;
+                    if (idx3) {
+                        while (idx3--) {
+                            const io = s.indexOf(this.options.assumeAdditional[idx3]);
+                            if (io !== -1) {
+                                s.splice(io, 1);
+                            }
                         }
                     }
                 }
                 let idx4 = s.length;
                 if (idx4) {
                     while (idx4--) {
-                        report.addError('OBJECT_ADDITIONAL_PROPERTIES', [s[idx4]], null, schema);
+                        report.addError('OBJECT_ADDITIONAL_PROPERTIES', [s[idx4]], undefined, schema);
                     }
                 }
             }
@@ -273,7 +285,7 @@ export const JsonValidators = {
         if (shouldSkipValidate(this.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
             return;
         }
-        if (Utils.whatIs(json) !== 'object') {
+        if (!isObject(json)) {
             return;
         }
         const keys = Object.keys(schema.dependencies);
@@ -283,21 +295,21 @@ export const JsonValidators = {
             const dependencyName = keys[idx];
             if (json[dependencyName]) {
                 const dependencyDefinition = schema.dependencies[dependencyName];
-                if (Utils.whatIs(dependencyDefinition) === 'object') {
-                    // if dependency is a schema, validate against this schema
-                    validate.call(this, report, dependencyDefinition, json);
-                }
-                else {
+                if (Array.isArray(dependencyDefinition)) {
                     // Array
                     // if dependency is an array, object needs to have all properties in this array
                     let idx2 = dependencyDefinition.length;
                     while (idx2--) {
                         const requiredPropertyName = dependencyDefinition[idx2];
                         if (json[requiredPropertyName] === undefined) {
-                            report.addError('OBJECT_DEPENDENCY_KEY', [requiredPropertyName, dependencyName], null, schema);
+                            report.addError('OBJECT_DEPENDENCY_KEY', [requiredPropertyName, dependencyName], undefined, schema);
                         }
                     }
                 }
+                else {
+                    // if dependency is a schema, validate against this schema
+                    validate.call(this, report, dependencyDefinition, json);
+                }
             }
         }
     },
@@ -308,17 +320,17 @@ export const JsonValidators = {
         }
         let match = false, caseInsensitiveMatch = false, idx = schema.enum.length;
         while (idx--) {
-            if (Utils.areEqual(json, schema.enum[idx])) {
+            if (areEqual(json, schema.enum[idx])) {
                 match = true;
                 break;
             }
-            else if (Utils.areEqual(json, schema.enum[idx], { caseInsensitiveComparison: true })) {
+            else if (areEqual(json, schema.enum[idx], { caseInsensitiveComparison: true })) {
                 caseInsensitiveMatch = true;
             }
         }
         if (match === false) {
             const error = caseInsensitiveMatch && this.options.enumCaseInsensitiveComparison ? 'ENUM_CASE_MISMATCH' : 'ENUM_MISMATCH';
-            report.addError(error, [json], null, schema);
+            report.addError(error, [JSON.stringify(json)], undefined, schema);
         }
     },
     type: function (report, schema, json) {
@@ -326,15 +338,15 @@ export const JsonValidators = {
         if (shouldSkipValidate(this.validateOptions, ['INVALID_TYPE'])) {
             return;
         }
-        const jsonType = Utils.whatIs(json);
+        const jsonType = whatIs(json);
         if (typeof schema.type === 'string') {
             if (jsonType !== schema.type && (jsonType !== 'integer' || schema.type !== 'number')) {
-                report.addError('INVALID_TYPE', [schema.type, jsonType], null, schema);
+                report.addError('INVALID_TYPE', [schema.type, jsonType], undefined, schema);
             }
         }
         else {
             if (schema.type.indexOf(jsonType) === -1 && (jsonType !== 'integer' || schema.type.indexOf('number') === -1)) {
-                report.addError('INVALID_TYPE', [schema.type, jsonType], null, schema);
+                report.addError('INVALID_TYPE', [JSON.stringify(schema.type), jsonType], undefined, schema);
             }
         }
     },
@@ -378,39 +390,40 @@ export const JsonValidators = {
             report.addError('ONE_OF_MISSING', undefined, subReports, schema);
         }
         else if (passes > 1) {
-            report.addError('ONE_OF_MULTIPLE', null, null, schema);
+            report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema);
         }
     },
     not: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.2
         const subReport = new Report(report);
         if (validate.call(this, subReport, schema.not, json) === true) {
-            report.addError('NOT_PASSED', null, null, schema);
+            report.addError('NOT_PASSED', undefined, undefined, schema);
         }
     },
     definitions: function () {
-        /*report, schema, json*/
+        /*report: Report, schema: JsonSchemaInternal, json: unknown*/
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.2
         // nothing to do here
     },
     format: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.7.2
-        const formatValidatorFn = FormatValidators[schema.format];
+        const formatValidators = getFormatValidators(this.options);
+        const formatValidatorFn = formatValidators[schema.format];
         if (typeof formatValidatorFn === 'function') {
             if (shouldSkipValidate(this.validateOptions, ['INVALID_FORMAT'])) {
                 return;
             }
-            if (report.hasError('INVALID_TYPE', [schema.type, Utils.whatIs(json)])) {
+            if (report.hasError('INVALID_TYPE', [schema.type, whatIs(json)])) {
                 return;
             }
             if (formatValidatorFn.length === 2) {
                 // async - need to clone the path here, because it will change by the time async function reports back
-                const pathBeforeAsync = Utils.clone(report.path);
+                const pathBeforeAsync = shallowClone(report.path);
                 report.addAsyncTask(formatValidatorFn, [json], function (result) {
                     if (result !== true) {
                         const backup = report.path;
                         report.path = pathBeforeAsync;
-                        report.addError('INVALID_FORMAT', [schema.format, json], null, schema);
+                        report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema);
                         report.path = backup;
                     }
                 });
@@ -418,12 +431,12 @@ export const JsonValidators = {
             else {
                 // sync
                 if (formatValidatorFn.call(this, json) !== true) {
-                    report.addError('INVALID_FORMAT', [schema.format, json], null, schema);
+                    report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema);
                 }
             }
         }
         else if (this.options.ignoreUnknownFormats !== true) {
-            report.addError('UNKNOWN_FORMAT', [schema.format], null, schema);
+            report.addError('UNKNOWN_FORMAT', [schema.format], undefined, schema);
         }
     },
 };
@@ -509,18 +522,12 @@ const recurseObject = function (report, schema, json) {
         }
     }
 };
-/**
- *
- * @param {Report} report
- * @param {*} schema
- * @param {*} json
- */
 export function validate(report, schema, json) {
     report.commonErrorMessage = 'JSON_OBJECT_VALIDATION_FAILED';
     // check if schema is an object
-    const to = Utils.whatIs(schema);
+    const to = whatIs(schema);
     if (to !== 'object') {
-        report.addError('SCHEMA_NOT_AN_OBJECT', [to], null, schema);
+        report.addError('SCHEMA_NOT_AN_OBJECT', [to], undefined, schema);
         return false;
     }
     // check if schema is empty, everything is valid against empty schema
@@ -540,7 +547,7 @@ export function validate(report, schema, json) {
         let maxRefs = 99;
         while (schema.$ref && maxRefs > 0) {
             if (!schema.__$refResolved) {
-                report.addError('REF_UNRESOLVED', [schema.$ref], null, schema);
+                report.addError('REF_UNRESOLVED', [schema.$ref], undefined, schema);
                 break;
             }
             else if (schema.__$refResolved === schema) {
@@ -557,7 +564,6 @@ export function validate(report, schema, json) {
         }
     }
     // type checking first
-    const jsonType = Utils.whatIs(json);
     if (schema.type) {
         keys.splice(keys.indexOf('type'), 1);
         JsonValidators.type.call(this, report, schema, json);
@@ -576,10 +582,10 @@ export function validate(report, schema, json) {
         }
     }
     if (report.errors.length === 0 || this.options.breakOnFirstError === false) {
-        if (jsonType === 'array') {
+        if (Array.isArray(json)) {
             recurseArray.call(this, report, schema, json);
         }
-        else if (jsonType === 'object') {
+        else if (isObject(json)) {
             recurseObject.call(this, report, schema, json);
         }
     }

package/dist/{Report.js → report.js}

@@ -1,29 +1,22 @@
 import get from 'lodash.get';
-import { Errors } from './Errors.js';
-import * as Utils from './Utils.js';
+import { Errors } from './errors.js';
+import { whatIs } from './utils/what-is.js';
+import { schemaSymbol, jsonSymbol } from './utils/symbols.js';
+import { isAbsoluteUri } from './utils/uri.js';
 export class Report {
-    errors;
+    asyncTasks = [];
+    commonErrorMessage;
+    errors = [];
+    json;
+    path = [];
+    rootSchema;
     parentReport;
     options;
     reportOptions;
-    path;
-    asyncTasks;
-    rootSchema;
-    commonErrorMessage;
-    json;
     constructor(parentOrOptions, reportOptions) {
         this.parentReport = parentOrOptions instanceof Report ? parentOrOptions : undefined;
         this.options = parentOrOptions instanceof Report ? parentOrOptions.options : parentOrOptions || {};
         this.reportOptions = reportOptions || {};
-        this.errors = [];
-        /**
-         * @type {string[]}
-         */
-        this.path = [];
-        this.asyncTasks = [];
-        this.rootSchema = undefined;
-        this.commonErrorMessage = undefined;
-        this.json = undefined;
     }
     isValid() {
         if (this.asyncTasks.length > 0) {
@@ -54,17 +47,15 @@ export class Report {
                 callback(err, valid);
             }, 0);
         };
-        function respond(asyncTaskResultProcessFn) {
-            return function (asyncTaskResult) {
-                if (timedOut) {
-                    return;
-                }
-                asyncTaskResultProcessFn(asyncTaskResult);
-                if (--tasksCount === 0) {
-                    finish();
-                }
-            };
-        }
+        const respond = (asyncTaskResultProcessFn) => (asyncTaskResult) => {
+            if (timedOut) {
+                return;
+            }
+            asyncTaskResultProcessFn(asyncTaskResult);
+            if (--tasksCount === 0) {
+                finish();
+            }
+        };
         // finish if tasks are completed or there are any errors and breaking on first error was requested
         if (tasksCount === 0 || (this.errors.length > 0 && this.options.breakOnFirstError)) {
             finish();
@@ -84,9 +75,6 @@ export class Report {
         }, validationTimeout);
     }
     getPath(returnPathAsString) {
-        /**
-         * @type {string[]|string}
-         */
         let path = [];
         if (this.parentReport) {
             path = path.concat(this.parentReport.path);
@@ -98,7 +86,7 @@ export class Report {
                 path
                     .map(function (segment) {
                     segment = segment.toString();
-                    if (Utils.isAbsoluteUri(segment)) {
+                    if (isAbsoluteUri(segment)) {
                         return 'uri(' + segment + ')';
                     }
                     return segment.replace(/~/g, '~0').replace(/\//g, '~1');
@@ -109,7 +97,7 @@ export class Report {
     }
     getSchemaId() {
         if (!this.rootSchema) {
-            return null;
+            return undefined;
         }
         // get the error path as an array
         let path = [];
@@ -128,16 +116,16 @@ export class Report {
         // return id of the root
         return this.rootSchema.id;
     }
-    hasError(errorCode, params) {
+    hasError(errCode, errParams) {
         let idx = this.errors.length;
         while (idx--) {
-            if (this.errors[idx].code === errorCode) {
+            if (this.errors[idx].code === errCode) {
                 // assume match
                 let match = true;
                 // check the params too
                 let idx2 = this.errors[idx].params.length;
                 while (idx2--) {
-                    if (this.errors[idx].params[idx2] !== params[idx2]) {
+                    if (this.errors[idx].params[idx2] !== errParams[idx2]) {
                         match = false;
                     }
                 }
@@ -149,12 +137,13 @@ export class Report {
         }
         return false;
     }
-    addError(errorCode, params, subReports, schema) {
-        if (!errorCode) {
+    addError(errCode, errParams, subReports, schema) {
+        if (!errCode) {
             throw new Error('No errorCode passed into addError()');
         }
-        this.addCustomError(errorCode, Errors[errorCode], params, subReports, schema);
+        this.addCustomError(errCode, Errors[errCode], errParams, subReports, schema);
     }
+    // this returns the root object being validated (the one passed into validator.validate)
     getJson() {
         if (this.json) {
             return this.json;
@@ -165,7 +154,7 @@ export class Report {
         return undefined;
     }
     addCustomError(errorCode, errorMessage, params, subReports, schema) {
-        if (this.errors.length >= this.reportOptions.maxErrors) {
+        if (typeof this.reportOptions.maxErrors === 'number' && this.errors.length >= this.reportOptions.maxErrors) {
             return;
         }
         if (!errorMessage) {
@@ -174,9 +163,9 @@ export class Report {
         params = params || [];
         let idx = params.length;
         while (idx--) {
-            const whatIs = Utils.whatIs(params[idx]);
-            const param = whatIs === 'object' || whatIs === 'null' ? JSON.stringify(params[idx]) : params[idx];
-            errorMessage = errorMessage.replace('{' + idx + '}', param);
+            const paramType = whatIs(params[idx]);
+            const param = paramType === 'object' || paramType === 'null' ? JSON.stringify(params[idx]) : params[idx];
+            errorMessage = errorMessage.replace('{' + idx + '}', param.toString());
         }
         const err = {
             code: errorCode,
@@ -185,8 +174,9 @@ export class Report {
             path: this.getPath(this.options.reportPathAsArray),
             schemaId: this.getSchemaId(),
         };
-        err[Utils.schemaSymbol] = schema;
-        err[Utils.jsonSymbol] = this.getJson();
+        // TODO v8: remove Symbol usage
+        err[schemaSymbol] = schema;
+        err[jsonSymbol] = this.getJson();
         if (schema && typeof schema === 'string') {
             err.description = schema;
         }