z-schema 9.0.1 → 10.0.0

package/dist/errors.js

@@ -47,6 +47,11 @@ export const Errors = {
     ASYNC_TIMEOUT: '{0} asynchronous task(s) have timed out after {1} ms',
     PARENT_SCHEMA_VALIDATION_FAILED: 'Schema failed to validate against its parent schema, see inner errors for details.',
     REMOTE_NOT_VALID: "Remote reference didn't compile successfully: {0}",
+    // Draft-06 errors
+    SCHEMA_IS_FALSE: 'Boolean schema "false" is always invalid.',
+    CONST: 'Value does not match const: {0}',
+    CONTAINS: 'Array does not contain an item matching the schema',
+    PROPERTY_NAMES: 'Property name {0} does not match the propertyNames schema',
 };
 export class ValidateError extends Error {
     name;

package/dist/format-validators.js

@@ -191,6 +191,65 @@ const uriValidator = function (uri) {
     }
     return /^[a-zA-Z][a-zA-Z0-9+.-]*:[^"\\<>^{}^`| ]*$/.test(uri);
 };
+const uriReferenceValidator = (uri) => {
+    if (typeof uri !== 'string')
+        return true;
+    // eslint-disable-next-line no-control-regex
+    if (/[^\x00-\x7F]/.test(uri))
+        return false;
+    // URI-reference allows relative URIs
+    return /^([a-zA-Z][a-zA-Z0-9+.-]*:)?[^"\\<>^{}^`| ]*$/.test(uri);
+};
+const uriTemplateValidator = (uri) => {
+    if (typeof uri !== 'string')
+        return true;
+    // URI template allows braces for expressions.
+    if (!/^([a-zA-Z][a-zA-Z0-9+.-]*:)?[^"\\<>^`| ]*$/.test(uri)) {
+        return false;
+    }
+    let inExpression = false;
+    for (let idx = 0; idx < uri.length; idx++) {
+        const ch = uri[idx];
+        if (ch === '{') {
+            if (inExpression) {
+                return false;
+            }
+            inExpression = true;
+        }
+        else if (ch === '}') {
+            if (!inExpression) {
+                return false;
+            }
+            inExpression = false;
+        }
+    }
+    return !inExpression;
+};
+const jsonPointerValidator = (pointer) => {
+    if (typeof pointer !== 'string')
+        return true;
+    // JSON Pointer: empty, or a sequence of '/'-prefixed reference tokens.
+    // In each token, '~' must be escaped as '~0' or '~1'.
+    return pointer === '' || /^(?:\/(?:[^~]|~0|~1)*)+$/.test(pointer);
+};
+const relativeJsonPointerValidator = (pointer) => {
+    if (typeof pointer !== 'string')
+        return true;
+    // Relative JSON Pointer: number#path or empty
+    return /^\d+(#.*)?$/.test(pointer) || pointer === '';
+};
+const timeValidator = (time) => {
+    if (typeof time !== 'string')
+        return true;
+    // time: hh:mm:ss[.fraction]
+    return /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(\.\d+)?$/.test(time);
+};
+const idnEmailValidator = (email) => {
+    if (typeof email !== 'string')
+        return true;
+    // Simple email check, allowing international chars
+    return /^[^\s@]+@[^\s@]+$/.test(email);
+};
 const inbuiltValidators = {
     date: dateValidator,
     'date-time': dateTimeValidator,
@@ -202,6 +261,12 @@ const inbuiltValidators = {
     regex: regexValidator,
     uri: uriValidator,
     'strict-uri': strictUriValidator,
+    'uri-reference': uriReferenceValidator,
+    'uri-template': uriTemplateValidator,
+    'json-pointer': jsonPointerValidator,
+    'relative-json-pointer': relativeJsonPointerValidator,
+    time: timeValidator,
+    'idn-email': idnEmailValidator,
 };
 const customValidators = {};
 export function getFormatValidators(options) {

package/dist/json-schema-versions.js

@@ -0,0 +1,5 @@
+export const CURRENT_DEFAULT_SCHEMA_VERSION = 'draft-06';
+export const VERSION_SCHEMA_URL_MAPPING = {
+    'draft-04': 'http://json-schema.org/draft-04/schema#',
+    'draft-06': 'http://json-schema.org/draft-06/schema#',
+};

package/dist/json-schema.js

@@ -1,6 +1,12 @@
 import { isObject } from './utils/what-is.js';
-export const VERSION_SCHEMA_URL_MAPPING = {
-    'draft-04': 'http://json-schema.org/draft-04/schema#',
+export const getId = (schema) => {
+    if (schema.$id) {
+        return schema.$id;
+    }
+    if (schema.id) {
+        return schema.id;
+    }
+    return undefined;
 };
 export const findId = (schema, id) => {
     // process only arrays and objects
@@ -11,8 +17,9 @@ export const findId = (schema, id) => {
     if (!id) {
         return schema;
     }
-    if (schema.id) {
-        if (schema.id === id || (schema.id[0] === '#' && schema.id.substring(1) === id)) {
+    const schemaId = getId(schema);
+    if (schemaId) {
+        if (schemaId === id || (schemaId[0] === '#' && schemaId.substring(1) === id)) {
             return schema;
         }
     }

package/dist/json-validation.js

@@ -54,8 +54,20 @@ export const JsonValidators = {
             }
         }
     },
-    exclusiveMaximum: function () {
-        // covered in maximum
+    exclusiveMaximum: function (report, schema, json) {
+        // In draft-06+, exclusiveMaximum is a standalone number
+        if (typeof schema.exclusiveMaximum === 'number') {
+            if (shouldSkipValidate(this.validateOptions, ['MAXIMUM_EXCLUSIVE'])) {
+                return;
+            }
+            if (typeof json !== 'number') {
+                return;
+            }
+            if (json >= schema.exclusiveMaximum) {
+                report.addError('MAXIMUM_EXCLUSIVE', [json, schema.exclusiveMaximum], undefined, schema, 'exclusiveMaximum');
+            }
+        }
+        // In draft-04, exclusiveMaximum is a boolean handled inside the `maximum` validator
     },
     minimum: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.2
@@ -76,8 +88,20 @@ export const JsonValidators = {
             }
         }
     },
-    exclusiveMinimum: function () {
-        // covered in minimum
+    exclusiveMinimum: function (report, schema, json) {
+        // In draft-06+, exclusiveMinimum is a standalone number
+        if (typeof schema.exclusiveMinimum === 'number') {
+            if (shouldSkipValidate(this.validateOptions, ['MINIMUM_EXCLUSIVE'])) {
+                return;
+            }
+            if (typeof json !== 'number') {
+                return;
+            }
+            if (json <= schema.exclusiveMinimum) {
+                report.addError('MINIMUM_EXCLUSIVE', [json, schema.exclusiveMinimum], undefined, schema, 'exclusiveMinimum');
+            }
+        }
+        // In draft-04, exclusiveMinimum is a boolean handled inside the `minimum` validator
     },
     maxLength: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.2
@@ -256,7 +280,11 @@ export const JsonValidators = {
             // for each regex in "pp", remove all elements of "s" which this regex matches.
             let idx = pp.length;
             while (idx--) {
-                const regExp = RegExp(pp[idx]);
+                const result = compileSchemaRegex(pp[idx]);
+                if (!result.ok) {
+                    continue;
+                }
+                const regExp = result.value;
                 let idx2 = s.length;
                 while (idx2--) {
                     if (regExp.test(s[idx2]) === true) {
@@ -549,6 +577,112 @@ export const JsonValidators = {
             report.addError('UNKNOWN_FORMAT', [schema.format], undefined, schema, 'format');
         }
     },
+    // draft-06 additions
+    $id: () => {
+        // TODO: implement
+    },
+    const: function (report, schema, json) {
+        const constValue = schema.const;
+        if (areEqual(json, constValue) === false) {
+            report.addError('CONST', [JSON.stringify(constValue)], undefined, schema, undefined);
+        }
+    },
+    contains: function (report, schema, json) {
+        if (shouldSkipValidate(this.validateOptions, ['CONTAINS'])) {
+            return;
+        }
+        if (!Array.isArray(json)) {
+            return;
+        }
+        const containsSchema = schema.contains;
+        if (containsSchema === undefined) {
+            return;
+        }
+        const subReports = [];
+        let idx = json.length;
+        while (idx--) {
+            const subReport = new Report(report);
+            subReports.push(subReport);
+            validate.call(this, subReport, containsSchema, json[idx]);
+        }
+        const asyncTasksBefore = report.asyncTasks.length;
+        for (const subReport of subReports) {
+            report.asyncTasks.push(...subReport.asyncTasks);
+        }
+        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
+        const addContainsErrorIfNeeded = () => {
+            let hasValidItem = false;
+            for (const subReport of subReports) {
+                if (subReport.errors.length === 0) {
+                    hasValidItem = true;
+                    break;
+                }
+            }
+            if (!hasValidItem) {
+                report.addError('CONTAINS', undefined, subReports, schema, undefined);
+            }
+        };
+        if (hasAsyncTasks) {
+            const pathBeforeAsync = shallowClone(report.path);
+            report.addAsyncTask((callback) => {
+                setTimeout(() => callback(null), 0);
+            }, [], () => {
+                const backup = report.path;
+                report.path = pathBeforeAsync;
+                addContainsErrorIfNeeded();
+                report.path = backup;
+            });
+            return;
+        }
+        addContainsErrorIfNeeded();
+    },
+    examples: () => {
+        // TODO: implement
+    },
+    propertyNames: function (report, schema, json) {
+        if (shouldSkipValidate(this.validateOptions, ['PROPERTY_NAMES'])) {
+            return;
+        }
+        if (!isObject(json)) {
+            return;
+        }
+        const propertyNamesSchema = schema.propertyNames;
+        if (propertyNamesSchema === undefined) {
+            return;
+        }
+        const keys = Object.keys(json);
+        const subReports = [];
+        for (const key of keys) {
+            const subReport = new Report(report);
+            subReports.push(subReport);
+            validate.call(this, subReport, propertyNamesSchema, key);
+        }
+        const asyncTasksBefore = report.asyncTasks.length;
+        for (const subReport of subReports) {
+            report.asyncTasks.push(...subReport.asyncTasks);
+        }
+        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
+        const addPropertyNameErrors = () => {
+            for (let idx = 0; idx < keys.length; idx++) {
+                if (subReports[idx].errors.length > 0) {
+                    report.addError('PROPERTY_NAMES', [keys[idx]], subReports[idx], schema, undefined);
+                }
+            }
+        };
+        if (hasAsyncTasks) {
+            const pathBeforeAsync = shallowClone(report.path);
+            report.addAsyncTask((callback) => {
+                setTimeout(() => callback(null), 0);
+            }, [], () => {
+                const backup = report.path;
+                report.path = pathBeforeAsync;
+                addPropertyNameErrors();
+                report.path = backup;
+            });
+            return;
+        }
+        addPropertyNameErrors();
+    },
 };
 const recurseArray = function (report, schema, json) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.8.2
@@ -575,7 +709,7 @@ const recurseArray = function (report, schema, json) {
             }
         }
     }
-    else if (typeof schema.items === 'object') {
+    else if (typeof schema.items === 'object' || typeof schema.items === 'boolean') {
         // If items is a schema, then the child instance must be valid against this schema,
         // regardless of its index, and regardless of the value of "additionalItems".
         while (idx--) {
@@ -615,7 +749,8 @@ const recurseObject = function (report, schema, json) {
         let idx2 = pp.length;
         while (idx2--) {
             const regexString = pp[idx2];
-            if (RegExp(regexString).test(m) === true) {
+            const result = compileSchemaRegex(regexString);
+            if (result.ok && result.value.test(m) === true) {
                 s.push(schema.patternProperties[regexString]);
             }
         }
@@ -651,10 +786,16 @@ const recurseObject = function (report, schema, json) {
 };
 export function validate(report, schema, json) {
     report.commonErrorMessage = 'JSON_OBJECT_VALIDATION_FAILED';
+    if (schema === true) {
+        return true;
+    }
+    if (schema === false) {
+        report.addError('SCHEMA_IS_FALSE', [], undefined, schema);
+        return false;
+    }
     // check if schema is an object
-    const to = whatIs(schema);
-    if (to !== 'object') {
-        report.addError('SCHEMA_NOT_AN_OBJECT', [to], undefined, schema);
+    if (!isObject(schema)) {
+        report.addError('SCHEMA_NOT_AN_OBJECT', [whatIs(schema)], undefined, schema);
         return false;
     }
     // check if schema is empty, everything is valid against empty schema

package/dist/report.js

@@ -2,7 +2,7 @@ import { Errors, getValidateError } from './errors.js';
 import { get } from './utils/json.js';
 import { jsonSymbol, schemaSymbol } from './utils/symbols.js';
 import { isAbsoluteUri } from './utils/uri.js';
-import { whatIs } from './utils/what-is.js';
+import { isObject } from './utils/what-is.js';
 export class Report {
     asyncTasks = [];
     commonErrorMessage;
@@ -183,8 +183,7 @@ export class Report {
         params = params || [];
         let idx = params.length;
         while (idx--) {
-            const paramType = whatIs(params[idx]);
-            const param = paramType === 'object' || paramType === 'null' ? JSON.stringify(params[idx]) : params[idx];
+            const param = params[idx] === null || isObject(params[idx]) ? JSON.stringify(params[idx]) : params[idx];
             errorMessage = errorMessage.replace('{' + idx + '}', param.toString());
         }
         const err = {

package/dist/schema-cache.js

@@ -1,4 +1,4 @@
-import { findId } from './json-schema.js';
+import { findId, getId } from './json-schema.js';
 import { Report } from './report.js';
 import { deepClone } from './utils/clone.js';
 import { decodeJSONPointer } from './utils/json.js';
@@ -49,7 +49,9 @@ export class SchemaCache {
             return this.cache[path];
         }
         const asClone = (s) => {
-            s.id ??= path;
+            if (!s.id || (!isAbsoluteUri(s.id) && isAbsoluteUri(path))) {
+                s.id = path;
+            }
             return deepClone(s);
         };
         found = SchemaCache.global_cache[path];
@@ -59,9 +61,28 @@ export class SchemaCache {
         return undefined;
     }
     getSchemaByUri(report, uri, root) {
+        if (root && !isAbsoluteUri(uri)) {
+            let rootId = getId(root);
+            if ((!rootId || !isAbsoluteUri(rootId)) && typeof root.id === 'string' && isAbsoluteUri(root.id)) {
+                rootId = root.id;
+            }
+            if (rootId && isAbsoluteUri(rootId)) {
+                const hashIndex = rootId.indexOf('#');
+                const rootBase = hashIndex === -1 ? rootId : rootId.slice(0, hashIndex);
+                try {
+                    uri = new URL(uri, rootBase).toString();
+                }
+                catch {
+                    // keep original uri when URL construction fails
+                }
+            }
+        }
         const remotePath = getRemotePath(uri);
         const queryPath = getQueryPath(uri);
         let result = remotePath ? this.fromCache(remotePath) : root;
+        if (result && remotePath && isAbsoluteUri(remotePath) && (!result.id || !isAbsoluteUri(result.id))) {
+            result.id = remotePath;
+        }
         if (result && remotePath) {
             // we need to avoid compiling schemas in a recursive loop
             const compileRemote = result !== root;

package/dist/schema-compiler.js

@@ -1,31 +1,38 @@
+import { getId } from './json-schema.js';
 import { Report } from './report.js';
 import { getRemotePath, isAbsoluteUri } from './utils/uri.js';
 import { getSchemaReader } from './z-schema-reader.js';
 export const collectIds = (obj) => {
     const ids = [];
+    const doNotCollectIdsFrom = ['enum', 'const', 'default', 'examples'];
     function walk(node, scope) {
         if (typeof node !== 'object' || node == null)
             return;
         let addedScope = false;
-        if (node.id && typeof node.id === 'string') {
-            let type = isAbsoluteUri(node.id) ? 'absolute' : 'relative';
+        const nodeId = getId(node);
+        if (typeof nodeId === 'string') {
+            let type = isAbsoluteUri(nodeId) ? 'absolute' : 'relative';
             if (scope.length === 0) {
                 type = 'root';
             }
             const id = {
-                id: node.id,
+                id: nodeId,
                 type,
                 obj: node,
             };
-            if (type === 'absolute' || (type === 'root' && isAbsoluteUri(node.id))) {
-                id.absoluteUri = node.id;
+            if (type === 'absolute' || (type === 'root' && isAbsoluteUri(nodeId))) {
+                id.absoluteUri = nodeId;
+            }
+            else if (type === 'root' && typeof node.id === 'string' && isAbsoluteUri(node.id) && node.id !== nodeId) {
+                id.absoluteUri = resolveIdScope(node.id, nodeId);
             }
             else if (type === 'relative') {
                 id.absoluteParent = scope
                     .filter((x) => x.type === 'absolute' || (x.type === 'root' && x.absoluteUri))
                     .slice(-1)[0];
                 if (id.absoluteParent) {
-                    id.absoluteUri = id.absoluteParent.id.split('/').slice(0, -1).concat(id.id).join('/');
+                    const parentUri = id.absoluteParent.absoluteUri || id.absoluteParent.id;
+                    id.absoluteUri = parentUri.split('/').slice(0, -1).concat(id.id).join('/');
                 }
             }
             ids.push(id);
@@ -39,7 +46,7 @@ export const collectIds = (obj) => {
         }
         else {
             for (const key of Object.keys(node)) {
-                if (key.indexOf('__$') === 0)
+                if (key.indexOf('__$') === 0 || doNotCollectIdsFrom.includes(key))
                     continue;
                 walk(node[key], scope);
             }
@@ -51,7 +58,7 @@ export const collectIds = (obj) => {
     walk(obj, []);
     return ids;
 };
-const doNotCollectReferencesFrom = ['enum'];
+const doNotCollectReferencesFrom = ['enum', 'const', 'default', 'examples'];
 export const collectReferences = (obj, results, scope, path) => {
     results = results || [];
     scope = scope || [];
@@ -62,9 +69,14 @@ export const collectReferences = (obj, results, scope, path) => {
     const hasRef = typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined';
     let addedScope = false;
     const isRootScope = scope.length === 0;
-    if (typeof obj.id === 'string' && (isRootScope || !hasRef)) {
+    const objId = getId(obj);
+    let scopeId = objId;
+    if (typeof obj.id === 'string' && isAbsoluteUri(obj.id) && (!scopeId || !isAbsoluteUri(scopeId))) {
+        scopeId = obj.id;
+    }
+    if (typeof scopeId === 'string' && (isRootScope || !hasRef)) {
         const base = scope.length > 0 ? scope[scope.length - 1] : undefined;
-        scope.push(resolveIdScope(base, obj.id));
+        scope.push(resolveIdScope(base, scopeId));
         addedScope = true;
     }
     if (hasRef) {
@@ -186,6 +198,9 @@ export class SchemaCompiler {
             }
             return this.compileArrayOfSchemas(report, schema);
         }
+        else if (typeof schema === 'boolean') {
+            return true;
+        }
         else {
             if (!options?.noCache) {
                 this.collectAndCacheIds(schema);