ata-validator 1.52.0 → 1.53.0

package/lib/compat-errors.js

@@ -31,6 +31,8 @@ const REFERENCE_ORDER = [
   'maxLength', 'minLength', 'pattern', 'format',
   'maxItems', 'minItems', 'additionalItems', 'prefixItems', 'items', 'contains', 'uniqueItems', 'maxContains', 'minContains', 'unevaluatedItems',
   'maxProperties', 'minProperties', 'required', 'propertyNames', 'additionalProperties', 'dependencies', 'dependentRequired', 'dependentSchemas', 'properties', 'patternProperties', 'unevaluatedProperties',
+  // The reference's `discriminator` option adds the keyword last.
+  'discriminator',
 ];
 const REFERENCE_RANK = new Map(REFERENCE_ORDER.map((k, i) => [k, i]));
 
@@ -78,13 +80,26 @@ function classify(segs) {
 // segments, and each segment's kind. Everything below used to re-derive these
 // wherever it needed them, which for one shaped rejection meant splitting the
 // same pointer three times per error.
+// Memoized by schemaPath: a schema reports a fixed set of paths, and a
+// rejection reshaped every error's path from scratch, which was a third of the
+// compat error path. The key is read, never written, by its users. Bounded so
+// a schema with paths that grow with the data (recursion) cannot fill memory.
+const _keys = new Map();
 function keyFor(e) {
-  const rel = pointerOf(e && e.schemaPath ? e.schemaPath : '#');
+  const sp = e && e.schemaPath ? e.schemaPath : '#';
+  let k = _keys.get(sp);
+  if (k !== undefined) return k;
+  const rel = pointerOf(sp);
   const segs = segments(rel);
-  return { rel, segs, kinds: classify(segs) };
+  k = { rel, segs, kinds: classify(segs) };
+  if (_keys.size >= 4096) _keys.clear();
+  _keys.set(sp, k);
+  return k;
 }
 
-function sortByKeys(errors, keys) {
+// `rankAt(segs, i)`, when given, can rank a keyword by where it sits: a
+// oneOf the discriminator decides is reported where the discriminator is.
+function sortByKeys(errors, keys, rankAt) {
   if (errors.length < 2) return errors.slice();
   const keyed = errors.map((e) => ({ e, k: keys.get(e) }));
   keyed.sort((A, B) => {
@@ -93,8 +108,8 @@ function sortByKeys(errors, keys) {
     for (let i = 0; i < n; i++) {
       if (pa[i] === pb[i]) continue;
       if (ka[i] !== 'kw') return 0;
-      const ra = REFERENCE_RANK.get(pa[i]);
-      const rb = REFERENCE_RANK.get(pb[i]);
+      const ra = rankAt ? rankAt(pa, i) : REFERENCE_RANK.get(pa[i]);
+      const rb = rankAt ? rankAt(pb, i) : REFERENCE_RANK.get(pb[i]);
       if (ra === undefined || rb === undefined) return 0;
       return ra - rb;
     }
@@ -143,7 +158,22 @@ function asReferenceKeyword(e) {
   return e.keyword === 'not' && e.message === 'boolean schema is false' ? { ...e, keyword: 'false schema' } : e;
 }
 
-function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors, macroKeywords }) {
+const FRAGMENT = 'ata-compat:fragment:';
+
+// Whether a schema holds a reference anywhere, the reference's test for
+// compiling a `$ref` target as a function of its own instead of inlining it.
+const REF_KEYWORDS = new Set(['$ref', '$recursiveRef', '$recursiveAnchor', '$dynamicRef', '$dynamicAnchor']);
+function hasRef(schema) {
+  if (schema === null || typeof schema !== 'object') return false;
+  for (const key in schema) {
+    if (REF_KEYWORDS.has(key)) return true;
+    const sch = schema[key];
+    if (Array.isArray(sch) ? sch.some(hasRef) : (sch !== null && typeof sch === 'object' && hasRef(sch))) return true;
+  }
+  return false;
+}
+
+function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors, macroKeywords, discriminator }) {
   const branchCache = new Map();
   const branchValidator = (pointer) => {
     let v = branchCache.get(pointer);
@@ -156,6 +186,74 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   const wrappers = new Set(WRAPPERS);
   for (const k of macroKeywords) wrappers.add(k);
 
+  // Where a schema path really points. ata reports a keyword reached through
+  // a local `$ref` at the referring node (`#/properties/s/maxLength`), the
+  // reference at the node the `$ref` names (`#/definitions/S/maxLength`).
+  // Walking the document, a segment the node does not have, on a node with a
+  // `#/...` `$ref`, continues at the target. Anything else stays as it is.
+  // Under the discriminator option a oneOf beside a `discriminator` is the
+  // discriminator's: its branch errors come where that keyword runs.
+  const discriminated = discriminator === true;
+  const rankAt = (segs, i) => {
+    if (segs[i] === 'oneOf') {
+      const node = walkPointer(rootDoc, canonical(segs.length && i > 0 ? '/' + segs.slice(0, i).join('/') : ''));
+      if (node !== null && typeof node === 'object' && node.discriminator && typeof node.discriminator.propertyName === 'string') return REFERENCE_RANK.get('discriminator');
+    }
+    return REFERENCE_RANK.get(segs[i]);
+  };
+  const canonCache = new Map();
+  const reportCache = new Map();
+  // `reported` false: the pointer of the node itself, to read the schema at.
+  // `reported` true: the path the reference reports, which differs after a
+  // `$ref` it compiles as a function of its own rather than inlining (one
+  // whose target holds a `$ref`): errors from there carry the path from
+  // that target, `#/...`, as if it were a root.
+  function follow(pointer, reported) {
+    const cache = reported ? reportCache : canonCache;
+    let out = cache.get(pointer);
+    if (out !== undefined) return out;
+    out = pointer;
+    let node = rootDoc, path = '', moved = false, ok = true;
+    for (const raw of segments(pointer)) {
+      const seg = unescape(raw);
+      let first = null, hops = 0;
+      for (; hops < 32 && node !== null && typeof node === 'object' && !Array.isArray(node) &&
+          !Object.prototype.hasOwnProperty.call(node, seg) && typeof node.$ref === 'string' &&
+          (node.$ref.startsWith('#/') || node.$ref.startsWith(FRAGMENT)); hops++) {
+        // A schema registered under a fragment-only key (see fragmentKey in
+        // compat.js) is named by that key, as the reference names it.
+        const registered = node.$ref.startsWith(FRAGMENT);
+        if (registered && !reported) { ok = false; break; }
+        let target;
+        try { target = decodeURIComponent(registered ? node.$ref.slice(FRAGMENT.length) : node.$ref.slice(1)); } catch { target = null; }
+        if (target === null) { ok = false; break; }
+        node = registered ? (schemas ? schemas[node.$ref] : undefined) : walkPointer(rootDoc, target);
+        if (first === null) first = target;
+        if (!reported) path = target;
+        moved = true;
+      }
+      if (!ok) break;
+      // A `$ref` to a `$ref` is reported at the first target, as the
+      // reference reports it, unless the reference compiled the last one on
+      // its own.
+      if (reported && first !== null) path = hasRef(node) ? '' : first;
+      if (node === null || typeof node !== 'object') { ok = false; break; }
+      node = Array.isArray(node) ? node[Number(seg)] : node[seg];
+      path += '/' + raw;
+    }
+    if (ok && moved && node !== undefined) out = path;
+    if (cache.size >= 4096) cache.clear();
+    cache.set(pointer, out);
+    return out;
+  }
+  const canonical = (pointer) => follow(pointer, false);
+  function canonicalError(e) {
+    const sp = e.schemaPath;
+    if (typeof sp !== 'string' || !sp.startsWith('#')) return e;
+    const c = follow(sp.slice(1), true);
+    return c === sp.slice(1) ? e : { ...e, schemaPath: '#' + c };
+  }
+
   // Errors whose schemaPath is already absolute (from the root), as opposed
   // to relative to the branch validator that produced them.
   const absolute = new WeakSet();
@@ -163,14 +261,16 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   // Returns the shaped errors of `value` against the subschema at `pointer`
   // (absolute), with schemaPath made absolute and instancePath rebased onto
   // the caller's.
-  function subErrors(pointer, value, schemaPrefix, instancePrefix) {
+  // `pointer` is where the subschema is; `at`, when given, is the path its
+  // errors are reported under, the referring one ata's own errors use.
+  function subErrors(pointer, value, schemaPrefix, instancePrefix, at) {
     const r = branchValidator(pointer).validate(value);
     if (r.valid) return null;
     const shaped = shape(r.errors, value, pointer);
     return shaped.map((e) => {
       const out = {
         ...e,
-        schemaPath: absolute.has(e) ? e.schemaPath : schemaPrefix + pointer + pointerOf(e.schemaPath || '#'),
+        schemaPath: absolute.has(e) ? e.schemaPath : schemaPrefix + (at === undefined ? pointer : at) + pointerOf(e.schemaPath || '#'),
         instancePath: instancePrefix + (e.instancePath || ''),
       };
       absolute.add(out);
@@ -187,7 +287,7 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   function shape(errors, data, basePointer) {
     const keys = new Map();
     for (const e of errors) keys.set(e, keyFor(e));
-    const sorted = sortByKeys(errors, keys);
+    const sorted = sortByKeys(errors, keys, discriminated ? rankAt : undefined);
     const out = [];
     const consumed = new Set();
     let thenGroup = null; // { prefix, which } for the pending `if` wrapper
@@ -208,7 +308,8 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
       if (consumed.has(e)) continue;
       const K = keys.get(e);
       const rel = K.rel;
-      const abs = basePointer + rel;
+      const raw = basePointer + rel;
+      const abs = canonical(raw);
       const segs = K.segs;
       const kinds = K.kinds;
       const schemaPrefix = (e.schemaPath || '#').slice(0, (e.schemaPath || '#').indexOf('#') + 1);
@@ -241,14 +342,25 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
           const value = walkData(data, e.instancePath || '');
           const branchErrors = [];
           const passing = [];
+          // The validator kept every branch's errors when keywords may have
+          // changed the data: validating a branch again would see the change.
+          const kept = basePointer === '' && Array.isArray(e._branches) && e._branches.length === branches.length ? e._branches : null;
           for (let i = 0; i < branches.length; i++) {
-            const errs = subErrors(abs + '/' + i, value, schemaPrefix, e.instancePath || '');
+            let errs;
+            if (kept !== null) {
+              errs = kept[i].valid ? null : shape(kept[i].errors, data, '');
+              if (errs !== null) for (const x of errs) absolute.add(x);
+            } else errs = subErrors(abs + '/' + i, value, schemaPrefix, e.instancePath || '', raw + '/' + i);
             if (errs === null) passing.push(i);
             else branchErrors.push(allErrors ? errs : errs.slice(0, groupEnd(errs)));
           }
           if (passing.length === 0) {
             for (const errs of branchErrors) out.push(...errs);
-            out.push(e);
+            // The reference's own wording and params for no branch passing;
+            // the collapsed error validate() reports names the count instead.
+            out.push(kw === 'oneOf'
+              ? keywordError('oneOf', e.instancePath || '', e.schemaPath, { passingSchemas: null }, 'must match exactly one schema in oneOf')
+              : keywordError('anyOf', e.instancePath || '', e.schemaPath, {}, 'must match a schema in anyOf'));
           } else if (kw === 'oneOf') {
             out.push({ ...e, params: { passingSchemas: passing }, message: 'must match exactly one schema in oneOf' });
           } else {
@@ -291,7 +403,7 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
         const items = walkData(data, e.instancePath || '');
         if (Array.isArray(items)) {
           for (let i = 0; i < items.length; i++) {
-            const errs = subErrors(abs, items[i], schemaPrefix, (e.instancePath || '') + '/' + i);
+            const errs = subErrors(abs, items[i], schemaPrefix, (e.instancePath || '') + '/' + i, raw);
             if (errs !== null) out.push(...errs);
           }
           out.push(e);
@@ -304,7 +416,7 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
       const depIndex = segs.findIndex((s, i) => kinds[i] === 'kw' && (s === 'dependentRequired' || s === 'dependentSchemas'));
       if (depIndex >= 0) {
         const nodePointer = basePointer + (depIndex === 0 ? '' : '/' + segs.slice(0, depIndex).join('/'));
-        const node = walkPointer(rootDoc, nodePointer);
+        const node = walkPointer(rootDoc, canonical(nodePointer));
         if (node && typeof node === 'object' && node.dependencies && typeof node.dependencies === 'object') {
           const rewritten = segs.slice();
           rewritten[depIndex] = 'dependencies';
@@ -379,7 +491,7 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
     if (e.keyword !== 'type' || typeof e.message !== 'string' || !e.message.startsWith('must be ')) return e;
     const ptr = pointerOf(e.schemaPath || '');
     if (!ptr.endsWith('/type')) return e;
-    const node = walkPointer(rootDoc, ptr.slice(0, -'/type'.length));
+    const node = walkPointer(rootDoc, canonical(ptr.slice(0, -'/type'.length)));
     let t = node && typeof node === 'object' && node.type !== undefined ? node.type : e.params && e.params.type;
     if (t === undefined) return e;
     if (node && node.nullable === true && Array.isArray(t) && !t.includes('null')) t = [...t, 'null'];
@@ -387,10 +499,12 @@ function createShaper({ Validator, rootId, rootDoc, schemas, options, allErrors,
   }
 
   return function shapeErrors(errors, data) {
+    // Paths are made the reference's last: the grouping above reads them as
+    // ata reports them, through the referring node.
     const shaped = shape(errors, data, '').map(asReferenceKeyword).map(asReferenceType);
-    if (allErrors) return shaped;
+    if (allErrors) return shaped.map(canonicalError);
     const n = groupEnd(shaped);
-    return shaped.slice(0, n);
+    return shaped.slice(0, n).map(canonicalError);
   };
 }
 

package/lib/draft7.js

@@ -91,34 +91,38 @@ function _normalize(schema, d6) {
   }
 
   // Recurse into object-valued sub-schemas
-  const objSubs = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
-  for (const key of objSubs) {
-    if (schema[key] && typeof schema[key] === 'object') {
-      for (const v of Object.values(schema[key])) {
+  for (const key of D7_OBJ_SUBS) {
+    const m = schema[key]
+    if (m && typeof m === 'object') {
+      for (const k in m) {
+        if (!Object.prototype.hasOwnProperty.call(m, k)) continue
+        const v = m[k]
         if (typeof v === 'object' && v !== null) _normalize(v, d6)
       }
     }
   }
 
   // Recurse into array-valued sub-schemas
-  const arrSubs = ['allOf', 'anyOf', 'oneOf', 'prefixItems']
-  for (const key of arrSubs) {
-    if (Array.isArray(schema[key])) {
-      for (const s of schema[key]) {
-        if (typeof s === 'object' && s !== null) _normalize(s, d6)
+  for (const key of D7_ARR_SUBS) {
+    const a = schema[key]
+    if (Array.isArray(a)) {
+      for (let i = 0; i < a.length; i++) {
+        const v = a[i]
+        if (typeof v === 'object' && v !== null) _normalize(v, d6)
       }
     }
   }
 
   // Recurse into single sub-schemas
-  const singleSubs = ['items', 'contains', 'not', 'if', 'then', 'else',
-                       'additionalProperties', 'propertyNames']
-  for (const key of singleSubs) {
-    if (typeof schema[key] === 'object' && schema[key] !== null) {
-      _normalize(schema[key], d6)
-    }
+  for (const key of D7_SINGLE_SUBS) {
+    const v = schema[key]
+    if (typeof v === 'object' && v !== null) _normalize(v, d6)
   }
 }
+// The schema-bearing keywords _normalize walks, built once rather than per node.
+const D7_OBJ_SUBS = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
+const D7_ARR_SUBS = ['allOf', 'anyOf', 'oneOf', 'prefixItems']
+const D7_SINGLE_SUBS = ['items', 'contains', 'not', 'if', 'then', 'else', 'additionalProperties', 'propertyNames']
 
 // OpenAPI `nullable: true` is not JSON Schema. Convert it to a union with
 // 'null' (`{ type: 'X', nullable: true }` -> `{ type: ['X', 'null'] }`), the
@@ -170,12 +174,36 @@ function _walkExclusive(node, seen) {
 
 function normalizeNullable(schema) {
   if (typeof schema !== 'object' || schema === null) return schema
-  _normalizeNullable(schema)
+  const st = { seen: new Set(), refs: [] }
+  _normalizeNullable(schema, st)
+  // A local `$ref` can point anywhere in the document, an OpenAPI
+  // `components` section among them, where the walk over subschema keywords
+  // does not go. A schema reached that way is a schema all the same, and its
+  // `nullable` is folded too.
+  while (st.refs.length > 0) {
+    const target = _localTarget(schema, st.refs.pop())
+    if (typeof target === 'object' && target !== null && !Array.isArray(target)) _normalizeNullable(target, st)
+  }
   return schema
 }
 
-function _normalizeNullable(schema) {
+function _localTarget(root, ref) {
+  if (ref === '#') return root
+  if (!ref.startsWith('#/')) return undefined
+  let node = root
+  for (const raw of ref.slice(2).split('/')) {
+    let seg = raw.replace(/~1/g, '/').replace(/~0/g, '~')
+    if (seg.includes('%')) { try { seg = decodeURIComponent(seg) } catch { return undefined } }
+    if (node === null || typeof node !== 'object' || !Object.prototype.hasOwnProperty.call(node, seg)) return undefined
+    node = node[seg]
+  }
+  return node
+}
+
+function _normalizeNullable(schema, st) {
   if (typeof schema !== 'object' || schema === null) return
+  if (st.seen.has(schema)) return
+  st.seen.add(schema)
 
   if (schema.nullable === true && schema.type !== undefined) {
     if (Array.isArray(schema.type)) {
@@ -195,37 +223,39 @@ function _normalizeNullable(schema) {
   // alone: the engines decode once more, and `100%` must not be decoded twice.
   // This walk is the one every normalization runs, so it costs no second pass;
   // a reference it does not reach keeps the old behaviour, the interpreter.
-  if (/^#.*%/.test(schema.$ref)) {
+  if (typeof schema.$ref === 'string' && schema.$ref.charCodeAt(0) === 35 && schema.$ref.indexOf('%') > 0) {
     try {
       const decoded = decodeURIComponent(schema.$ref)
       if (!decoded.includes('%')) schema.$ref = decoded
     } catch {}
   }
-
-  const objSubs = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']
-  for (const key of objSubs) {
-    if (schema[key] && typeof schema[key] === 'object') {
-      for (const v of Object.values(schema[key])) {
-        if (typeof v === 'object' && v !== null) _normalizeNullable(v)
+  if (typeof schema.$ref === 'string' && schema.$ref.charCodeAt(0) === 35) st.refs.push(schema.$ref)
+
+  for (const key of D7_OBJ_SUBS) {
+    const m = schema[key]
+    if (m && typeof m === 'object') {
+      for (const k in m) {
+        if (!Object.prototype.hasOwnProperty.call(m, k)) continue
+        const v = m[k]
+        if (typeof v === 'object' && v !== null) _normalizeNullable(v, st)
       }
     }
   }
-  const arrSubs = ['allOf', 'anyOf', 'oneOf', 'prefixItems']
-  for (const key of arrSubs) {
-    if (Array.isArray(schema[key])) {
-      for (const s of schema[key]) {
-        if (typeof s === 'object' && s !== null) _normalizeNullable(s)
+  for (const key of D7_ARR_SUBS) {
+    const a = schema[key]
+    if (Array.isArray(a)) {
+      for (let i = 0; i < a.length; i++) {
+        const v = a[i]
+        if (typeof v === 'object' && v !== null) _normalizeNullable(v, st)
       }
     }
   }
-  const singleSubs = ['items', 'contains', 'not', 'if', 'then', 'else',
-                       'additionalProperties', 'propertyNames', 'unevaluatedItems', 'unevaluatedProperties']
-  for (const key of singleSubs) {
-    if (typeof schema[key] === 'object' && schema[key] !== null) {
-      _normalizeNullable(schema[key])
-    }
+  for (const key of NULLABLE_SINGLE_SUBS) {
+    const v = schema[key]
+    if (typeof v === 'object' && v !== null) _normalizeNullable(v, st)
   }
 }
+const NULLABLE_SINGLE_SUBS = ['items', 'contains', 'not', 'if', 'then', 'else', 'additionalProperties', 'propertyNames', 'unevaluatedItems', 'unevaluatedProperties']
 
 // Draft 2020-12 treats `format` as an annotation unless the assertion
 // vocabulary is in use. Removing the keyword is exactly that reading, and it