z-schema 10.0.0 → 12.0.0

package/dist/report.js

@@ -1,4 +1,5 @@
 import { Errors, getValidateError } from './errors.js';
+import { shallowClone } from './utils/clone.js';
 import { get } from './utils/json.js';
 import { jsonSymbol, schemaSymbol } from './utils/symbols.js';
 import { isAbsoluteUri } from './utils/uri.js';
@@ -6,6 +7,9 @@ import { isObject } from './utils/what-is.js';
 export class Report {
     asyncTasks = [];
     commonErrorMessage;
+    __$recursiveAnchorStack = [];
+    __$dynamicScopeStack = [];
+    __validationResultCache = new Map();
     errors = [];
     json;
     path = [];
@@ -22,11 +26,17 @@ export class Report {
             // subreport
             this.reportOptions = reportOptionsOrValidate || {};
             this.validateOptions = validateOptions || parentOrOptions.validateOptions;
+            this.__$recursiveAnchorStack = [...parentOrOptions.__$recursiveAnchorStack];
+            this.__$dynamicScopeStack = [...parentOrOptions.__$dynamicScopeStack];
+            this.__validationResultCache = parentOrOptions.__validationResultCache;
         }
         else {
             // primary
             this.reportOptions = {};
             this.validateOptions = reportOptionsOrValidate || {};
+            this.__$recursiveAnchorStack = [];
+            this.__$dynamicScopeStack = [];
+            this.__validationResultCache = new Map();
         }
     }
     isValid() {
@@ -38,6 +48,25 @@ export class Report {
     addAsyncTask(fn, args, asyncTaskResultProcessFn) {
         this.asyncTasks.push([fn, args, asyncTaskResultProcessFn]);
     }
+    /**
+     * Like {@link addAsyncTask}, but automatically saves the current `path` and
+     * restores it around `processFn`.  This eliminates the manual
+     * path-save/restore boilerplate that every async-aware validator would
+     * otherwise need.
+     */
+    addAsyncTaskWithPath(fn, args, processFn) {
+        const pathBefore = shallowClone(this.path);
+        this.asyncTasks.push([
+            fn,
+            args,
+            (result) => {
+                const backup = this.path;
+                this.path = pathBefore;
+                processFn(result);
+                this.path = backup;
+            },
+        ]);
+    }
     getAncestor(id) {
         if (!this.parentReport) {
             return undefined;
@@ -50,7 +79,6 @@ export class Report {
     processAsyncTasks(timeout, callback) {
         const validationTimeout = timeout || 2000;
         let tasksCount = this.asyncTasks.length;
-        let idx = tasksCount;
         let timedOut = false;
         const finish = () => {
             setTimeout(() => {
@@ -73,8 +101,8 @@ export class Report {
             finish();
             return;
         }
-        while (idx--) {
-            const [fn, fnArgs, processFn] = this.asyncTasks[idx];
+        for (let i = 0; i < this.asyncTasks.length; i++) {
+            const [fn, fnArgs, processFn] = this.asyncTasks[i];
             const respondCallback = respond(processFn);
             fn(...fnArgs, respondCallback);
         }
@@ -137,14 +165,12 @@ export class Report {
         return this.rootSchema.id;
     }
     hasError(errCode, errParams) {
-        let idx = this.errors.length;
-        while (idx--) {
+        for (let idx = 0; idx < this.errors.length; idx++) {
             if (this.errors[idx].code === errCode) {
                 // assume match
                 let match = true;
                 // check the params too
-                let idx2 = this.errors[idx].params.length;
-                while (idx2--) {
+                for (let idx2 = 0; idx2 < this.errors[idx].params.length; idx2++) {
                     if (this.errors[idx].params[idx2] !== errParams[idx2]) {
                         match = false;
                     }
@@ -181,8 +207,7 @@ export class Report {
             throw new Error('No errorMessage known for code ' + errorCode);
         }
         params = params || [];
-        let idx = params.length;
-        while (idx--) {
+        for (let idx = 0; idx < params.length; idx++) {
             const param = params[idx] === null || isObject(params[idx]) ? JSON.stringify(params[idx]) : params[idx];
             errorMessage = errorMessage.replace('{' + idx + '}', param.toString());
         }
@@ -195,7 +220,6 @@ export class Report {
             schemaId: this.getSchemaId(),
             keyword: keyword,
         };
-        // TODO v8: remove Symbol usage
         err[schemaSymbol] = schema;
         err[jsonSymbol] = this.getJson();
         if (schema && typeof schema === 'string') {
@@ -214,12 +238,9 @@ export class Report {
                 subReports = [subReports];
             }
             err.inner = [];
-            idx = subReports.length;
-            while (idx--) {
-                const subReport = subReports[idx];
-                let idx2 = subReport.errors.length;
-                while (idx2--) {
-                    err.inner.push(subReport.errors[idx2]);
+            for (const subReport of subReports) {
+                for (const error of subReport.errors) {
+                    err.inner.push(error);
                 }
             }
             if (err.inner.length === 0) {

package/dist/schema-cache.js

@@ -3,6 +3,35 @@ import { Report } from './report.js';
 import { deepClone } from './utils/clone.js';
 import { decodeJSONPointer } from './utils/json.js';
 import { getQueryPath, getRemotePath, isAbsoluteUri } from './utils/uri.js';
+import { normalizeOptions } from './z-schema-options.js';
+const getEffectiveId = (schema) => {
+    let id = getId(schema);
+    if ((!id || !isAbsoluteUri(id)) && typeof schema.id === 'string' && isAbsoluteUri(schema.id)) {
+        id = schema.id;
+    }
+    return id;
+};
+/**
+ * Shared logic for registering a remote reference schema.
+ * Used by both the static `ZSchema.setRemoteReference()` (global cache) and
+ * the instance `validator.setRemoteReference()` (instance cache).
+ */
+export function prepareRemoteSchema(schema, uri, validationOptions, maxCloneDepth) {
+    let _schema;
+    if (typeof schema === 'string') {
+        _schema = JSON.parse(schema);
+    }
+    else {
+        _schema = deepClone(schema, maxCloneDepth);
+    }
+    if (!_schema.id) {
+        _schema.id = uri;
+    }
+    if (validationOptions) {
+        _schema.__$validationOptions = normalizeOptions(validationOptions);
+    }
+    return _schema;
+}
 export class SchemaCache {
     validator;
     static global_cache = {};
@@ -41,31 +70,29 @@ export class SchemaCache {
             return this.getSchemaByUri(report, refOrSchema);
         }
         // no caching done on this, but we need to return a clone so we can mutate it
-        return deepClone(refOrSchema);
+        return deepClone(refOrSchema, this.validator.options.maxRecursionDepth);
     }
     fromCache(path) {
         let found = this.cache[path];
         if (found) {
-            return this.cache[path];
+            return found;
         }
-        const asClone = (s) => {
-            if (!s.id || (!isAbsoluteUri(s.id) && isAbsoluteUri(path))) {
-                s.id = path;
-            }
-            return deepClone(s);
-        };
         found = SchemaCache.global_cache[path];
         if (found) {
-            return asClone(found);
+            // Clone once from global cache into instance cache so subsequent lookups
+            // never deep-clone again for the same path on this instance.
+            const clone = deepClone(found, this.validator.options.maxRecursionDepth);
+            if (!clone.id || (!isAbsoluteUri(clone.id) && isAbsoluteUri(path))) {
+                clone.id = path;
+            }
+            this.cache[path] = clone;
+            return clone;
         }
         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;
-            }
+            const rootId = getEffectiveId(root);
             if (rootId && isAbsoluteUri(rootId)) {
                 const hashIndex = rootId.indexOf('#');
                 const rootBase = hashIndex === -1 ? rootId : rootId.slice(0, hashIndex);
@@ -79,20 +106,40 @@ export class SchemaCache {
         }
         const remotePath = getRemotePath(uri);
         const queryPath = getQueryPath(uri);
-        let result = remotePath ? this.fromCache(remotePath) : root;
+        let result;
+        let resolvedFromAncestor = false;
+        if (remotePath) {
+            const ancestorReport = report.getAncestor(remotePath);
+            if (ancestorReport?.rootSchema) {
+                result = ancestorReport.rootSchema;
+                resolvedFromAncestor = true;
+            }
+        }
+        if (!result && root && remotePath) {
+            const rootId = getEffectiveId(root);
+            const rootRemotePath = rootId ? getRemotePath(rootId) : undefined;
+            if (rootRemotePath && rootRemotePath === remotePath) {
+                result = root;
+            }
+        }
+        if (!result) {
+            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;
+            const compileRemote = result !== root && !resolvedFromAncestor;
             // now we need to compile and validate resolved schema (in case it's not already)
             if (compileRemote) {
                 report.path.push(remotePath);
                 let remoteReport;
+                let usesAncestorReport = false;
                 const anscestorReport = result.id ? report.getAncestor(result.id) : undefined;
                 if (anscestorReport) {
                     remoteReport = anscestorReport;
+                    usesAncestorReport = true;
                 }
                 else {
                     remoteReport = new Report(report);
@@ -103,14 +150,21 @@ export class SchemaCache {
                             // If custom validationOptions were provided to setRemoteReference(),
                             // use them instead of the default options
                             this.validator.options = result.__$validationOptions || this.validator.options;
-                            this.validator.sv.validateSchema(remoteReport, result);
+                            const parentSchemaUri = typeof result.$schema === 'string' ? getRemotePath(result.$schema) : undefined;
+                            const currentSchemaUri = report.getSchemaId();
+                            const parentSchemaIsCompiling = !!parentSchemaUri &&
+                                parentSchemaUri.length > 0 &&
+                                (currentSchemaUri === parentSchemaUri || !!report.getAncestor(parentSchemaUri));
+                            if (!parentSchemaIsCompiling) {
+                                this.validator.sv.validateSchema(remoteReport, result);
+                            }
                         }
                         finally {
                             this.validator.options = savedOptions;
                         }
                     }
                 }
-                const remoteReportIsValid = remoteReport.isValid();
+                const remoteReportIsValid = usesAncestorReport ? true : remoteReport.isValid();
                 if (!remoteReportIsValid) {
                     report.addError('REMOTE_NOT_VALID', [uri], remoteReport);
                 }
@@ -120,13 +174,14 @@ export class SchemaCache {
                 }
             }
         }
+        const resourceRoot = result;
         if (result && queryPath) {
             const parts = queryPath.split('/');
             for (let idx = 0, lim = parts.length; result && idx < lim; idx++) {
                 const key = decodeJSONPointer(parts[idx]);
                 if (idx === 0) {
                     // it's an id
-                    result = findId(result, key);
+                    result = findId(result, key, remotePath, remotePath, this.validator.options.maxRecursionDepth);
                 }
                 else {
                     // it's a path behind id
@@ -134,6 +189,9 @@ export class SchemaCache {
                 }
             }
         }
+        if (result && typeof result === 'object' && resourceRoot && typeof resourceRoot === 'object') {
+            result.__$resourceRoot = resourceRoot;
+        }
         return result;
     }
 }

package/dist/schema-compiler.js

@@ -1,13 +1,17 @@
-import { getId } from './json-schema.js';
+import { getId, isInternalKey, NON_SCHEMA_KEYWORDS } from './json-schema.js';
 import { Report } from './report.js';
 import { getRemotePath, isAbsoluteUri } from './utils/uri.js';
+import { DEFAULT_MAX_RECURSION_DEPTH } from './z-schema-options.js';
 import { getSchemaReader } from './z-schema-reader.js';
-export const collectIds = (obj) => {
+export const collectIds = (obj, maxDepth = DEFAULT_MAX_RECURSION_DEPTH) => {
     const ids = [];
-    const doNotCollectIdsFrom = ['enum', 'const', 'default', 'examples'];
-    function walk(node, scope) {
+    function walk(node, scope, _depth = 0) {
         if (typeof node !== 'object' || node == null)
             return;
+        if (_depth >= maxDepth) {
+            throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in collectIds. ` +
+                'If your schema is deeply nested and valid, increase the maxRecursionDepth option.');
+        }
         let addedScope = false;
         const nodeId = getId(node);
         if (typeof nodeId === 'string') {
@@ -24,7 +28,7 @@ export const collectIds = (obj) => {
                 id.absoluteUri = nodeId;
             }
             else if (type === 'root' && typeof node.id === 'string' && isAbsoluteUri(node.id) && node.id !== nodeId) {
-                id.absoluteUri = resolveIdScope(node.id, nodeId);
+                id.absoluteUri = resolveSchemaScopeId(node.id, node, nodeId);
             }
             else if (type === 'relative') {
                 id.absoluteParent = scope
@@ -32,7 +36,7 @@ export const collectIds = (obj) => {
                     .slice(-1)[0];
                 if (id.absoluteParent) {
                     const parentUri = id.absoluteParent.absoluteUri || id.absoluteParent.id;
-                    id.absoluteUri = parentUri.split('/').slice(0, -1).concat(id.id).join('/');
+                    id.absoluteUri = resolveSchemaScopeId(parentUri, node, id.id);
                 }
             }
             ids.push(id);
@@ -41,14 +45,14 @@ export const collectIds = (obj) => {
         }
         if (Array.isArray(node)) {
             for (const item of node) {
-                walk(item, scope);
+                walk(item, scope, _depth + 1);
             }
         }
         else {
             for (const key of Object.keys(node)) {
-                if (key.indexOf('__$') === 0 || doNotCollectIdsFrom.includes(key))
+                if (isInternalKey(key) || NON_SCHEMA_KEYWORDS.includes(key))
                     continue;
-                walk(node[key], scope);
+                walk(node[key], scope, _depth + 1);
             }
         }
         if (addedScope) {
@@ -58,14 +62,18 @@ export const collectIds = (obj) => {
     walk(obj, []);
     return ids;
 };
-const doNotCollectReferencesFrom = ['enum', 'const', 'default', 'examples'];
-export const collectReferences = (obj, results, scope, path) => {
+export const collectReferences = (obj, results, scope, path, options, maxDepth = DEFAULT_MAX_RECURSION_DEPTH, _depth = 0) => {
     results = results || [];
     scope = scope || [];
     path = path || [];
+    options = options || {};
     if (typeof obj !== 'object' || obj === null) {
         return results;
     }
+    if (_depth >= maxDepth) {
+        throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in collectReferences. ` +
+            'If your schema is deeply nested and valid, increase the maxRecursionDepth option.');
+    }
     const hasRef = typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined';
     let addedScope = false;
     const isRootScope = scope.length === 0;
@@ -74,9 +82,9 @@ export const collectReferences = (obj, results, scope, path) => {
     if (typeof obj.id === 'string' && isAbsoluteUri(obj.id) && (!scopeId || !isAbsoluteUri(scopeId))) {
         scopeId = obj.id;
     }
-    if (typeof scopeId === 'string' && (isRootScope || !hasRef)) {
+    if (typeof scopeId === 'string' && (isRootScope || !hasRef || options.useRefObjectScope === true)) {
         const base = scope.length > 0 ? scope[scope.length - 1] : undefined;
-        scope.push(resolveIdScope(base, scopeId));
+        scope.push(resolveSchemaScopeId(base, obj, scopeId));
         addedScope = true;
     }
     if (hasRef) {
@@ -87,6 +95,22 @@ export const collectReferences = (obj, results, scope, path) => {
             path: path.slice(0),
         });
     }
+    if (typeof obj.$recursiveRef === 'string' && typeof obj.__$recursiveRefResolved === 'undefined') {
+        results.push({
+            ref: resolveReference(scope[scope.length - 1], obj.$recursiveRef),
+            key: '$recursiveRef',
+            obj: obj,
+            path: path.slice(0),
+        });
+    }
+    if (typeof obj.$dynamicRef === 'string' && typeof obj.__$dynamicRefResolved === 'undefined') {
+        results.push({
+            ref: resolveReference(scope[scope.length - 1], obj.$dynamicRef),
+            key: '$dynamicRef',
+            obj: obj,
+            path: path.slice(0),
+        });
+    }
     if (typeof obj.$schema === 'string' && typeof obj.__$schemaResolved === 'undefined') {
         results.push({
             ref: resolveReference(scope[scope.length - 1], obj.$schema),
@@ -95,25 +119,22 @@ export const collectReferences = (obj, results, scope, path) => {
             path: path.slice(0),
         });
     }
-    let idx;
     if (Array.isArray(obj)) {
-        idx = obj.length;
-        while (idx--) {
-            path.push(idx);
-            collectReferences(obj[idx], results, scope, path);
+        for (let i = 0; i < obj.length; i++) {
+            path.push(i);
+            collectReferences(obj[i], results, scope, path, options, maxDepth, _depth + 1);
             path.pop();
         }
     }
     else {
         const keys = Object.keys(obj);
-        idx = keys.length;
-        while (idx--) {
+        for (const key of keys) {
             // do not recurse through resolved references and other z-schema props
-            if (keys[idx].indexOf('__$') === 0 || doNotCollectReferencesFrom.includes(keys[idx])) {
+            if (isInternalKey(key) || NON_SCHEMA_KEYWORDS.includes(key)) {
                 continue;
             }
-            path.push(keys[idx]);
-            collectReferences(obj[keys[idx]], results, scope, path);
+            path.push(key);
+            collectReferences(obj[key], results, scope, path, options, maxDepth, _depth + 1);
             path.pop();
         }
     }
@@ -151,29 +172,41 @@ const resolveReference = (base, ref) => {
     }
     return baseDir + ref;
 };
+const isSimpleIdentifier = (id) => id[0] !== '#' && !id.includes('/') && !id.includes('.') && !id.includes('#');
 const resolveIdScope = (base, id) => {
     if (isAbsoluteUri(id)) {
         return id;
     }
     const baseStr = base ?? '';
     // Treat simple identifiers (no '/', '.', or '#') as same-document fragment ids
-    if (id[0] !== '#' && !id.includes('/') && !id.includes('.') && !id.includes('#')) {
+    if (isSimpleIdentifier(id)) {
         const hashIndex = baseStr.indexOf('#');
         const baseNoFrag = hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex);
         return baseNoFrag + '#' + id;
     }
     return resolveReference(base, id);
 };
+const resolveSchemaScopeId = (base, schema, id) => {
+    if (typeof schema.$id === 'string') {
+        return resolveReference(base, id);
+    }
+    return resolveIdScope(base, id);
+};
 export class SchemaCompiler {
     validator;
     constructor(validator) {
         this.validator = validator;
     }
     collectAndCacheIds(schema) {
-        const ids = collectIds(schema);
+        const ids = collectIds(schema, this.validator.options.maxRecursionDepth);
         for (const item of ids) {
             if (item.absoluteUri) {
                 this.validator.scache.cacheSchemaByUri(item.absoluteUri, item.obj);
+                if (item.type === 'relative' && item.absoluteParent && isSimpleIdentifier(item.id)) {
+                    const parentUri = item.absoluteParent.absoluteUri || item.absoluteParent.id;
+                    const altAbsoluteUri = resolveReference(parentUri, item.id);
+                    this.validator.scache.cacheSchemaByUri(altAbsoluteUri, item.obj);
+                }
             }
             else if (item.type === 'root') {
                 this.validator.scache.cacheSchemaByUri(item.id, item.obj);
@@ -185,7 +218,7 @@ export class SchemaCompiler {
         // if schema is a string, assume it's a uri
         if (typeof schema === 'string') {
             const loadedSchema = this.validator.scache.getSchemaByUri(report, schema);
-            if (!loadedSchema) {
+            if (typeof loadedSchema === 'undefined') {
                 report.addError('SCHEMA_NOT_REACHABLE', [schema]);
                 return false;
             }
@@ -232,21 +265,21 @@ export class SchemaCompiler {
         const isValidExceptReferences = report.isValid();
         delete schema.__$missingReferences;
         // collect all references that need to be resolved - $ref and $schema
-        const refs = collectReferences(schema);
-        let idx = refs.length;
-        while (idx--) {
+        const useRefObjectScope = this.validator.options.version === 'draft2019-09' || this.validator.options.version === 'draft2020-12';
+        const refs = collectReferences(schema, undefined, undefined, undefined, { useRefObjectScope }, this.validator.options.maxRecursionDepth);
+        for (const refObj of refs) {
             // resolve all the collected references into __xxxResolved pointer
-            const refObj = refs[idx];
             let response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
             // we can try to use custom schemaReader if available
-            if (!response) {
+            if (typeof response === 'undefined') {
                 const schemaReader = getSchemaReader();
                 if (schemaReader) {
                     const remotePath = getRemotePath(refObj.ref);
                     // it's supposed to return a valid schema
                     const s = schemaReader(remotePath);
                     if (s) {
-                        // it needs to have the id
+                        // it needs to have the id (cast: schemaReader returns JsonSchema, but
+                        // at this pre-compilation stage we treat it as an internal object)
                         s.id = remotePath;
                         // try to compile the schema
                         const subreport = new Report(report);
@@ -260,7 +293,7 @@ export class SchemaCompiler {
                     }
                 }
             }
-            if (!response) {
+            if (typeof response === 'undefined') {
                 const hasNotValid = report.hasError('REMOTE_NOT_VALID', [refObj.ref]);
                 const isAbsolute = isAbsoluteUri(refObj.ref);
                 let isDownloaded = false;
@@ -314,23 +347,15 @@ export class SchemaCompiler {
         let compiled = 0, lastLoopCompiled;
         do {
             // remove all UNRESOLVABLE_REFERENCE errors before compiling array again
-            let idx = report.errors.length;
-            while (idx--) {
-                if (report.errors[idx].code === 'UNRESOLVABLE_REFERENCE') {
-                    report.errors.splice(idx, 1);
-                }
-            }
+            report.errors = report.errors.filter((e) => e.code !== 'UNRESOLVABLE_REFERENCE');
             // remember how many were compiled in the last loop
             lastLoopCompiled = compiled;
             // count how many are compiled now
             compiled = this.compileArrayOfSchemasLoop(report, arr);
             // fix __$missingReferences if possible
-            idx = arr.length;
-            while (idx--) {
-                const sch = arr[idx];
+            for (const sch of arr) {
                 if (sch.__$missingReferences) {
-                    let idx2 = sch.__$missingReferences.length;
-                    while (idx2--) {
+                    for (let idx2 = sch.__$missingReferences.length - 1; idx2 >= 0; idx2--) {
                         const refObj = sch.__$missingReferences[idx2];
                         const response = arr.find((x) => x.id === refObj.ref);
                         if (response) {
@@ -350,11 +375,11 @@ export class SchemaCompiler {
         return report.isValid();
     }
     compileArrayOfSchemasLoop(mainReport, arr) {
-        let idx = arr.length, compiledCount = 0;
-        while (idx--) {
+        let compiledCount = 0;
+        for (const schema of arr) {
             // try to compile each schema separately
             const report = new Report(mainReport);
-            const isValid = this.compileSchema(report, arr[idx]);
+            const isValid = this.compileSchema(report, schema);
             if (isValid) {
                 compiledCount++;
             }