ata-validator 1.38.0 → 1.39.1

package/lib/rejections.js

@@ -76,7 +76,7 @@ class RichRejection {
   }
   _ataRaw() {
     let raw = this._result.errors || [];
-    if (raw.length > 1) raw = sortErrorsBySchemaOrder(this._root, raw);
+    if (needsOrdering(raw)) raw = sortErrorsBySchemaOrder(this._root, raw);
     return raw;
   }
 }
@@ -88,7 +88,7 @@ Object.defineProperty(RichRejection.prototype, 'errors', {
       const self = this._self;
       const enrich = this._enrich;
       let raw = this._result.errors || [];
-      if (raw.length > 1) raw = sortErrorsBySchemaOrder(this._root, raw);
+      if (needsOrdering(raw)) raw = sortErrorsBySchemaOrder(this._root, raw);
       // The position map, resolved now that an error is actually being read.
       let positions = null;
       if (enrich && raw.length && this._rawInput != null) {
@@ -172,7 +172,7 @@ Object.defineProperty(LazyJsonRejection.prototype, 'errors', {
       const positions = self._pos().targeted(jsonStr, wantedPointersFor(raw));
       // Declaration order, as validate() applies it; the text path used to
       // enrich in emission order.
-      const ordered = raw.length > 1 ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
+      const ordered = needsOrdering(raw) ? sortErrorsBySchemaOrder(self._schemaObj, raw) : raw;
       const enrichOpts = {
         data: parsedData,
         positions,
@@ -246,11 +246,23 @@ function wantedPointersFor (errors) {
   return wanted;
 }
 
-// A raw error without the `_o` ordering key, for the legacy error shape.
+// A raw error in the legacy shape. The error generator writes `code` and
+// `docUrl` into its literals because a standalone module returns them as they
+// are; the runtime's legacy shape never had them, and the interpreter leaves
+// them out, so they are dropped here with the ordering key `_o`. A collapsed
+// oneOf/anyOf error keeps its code, which both engines give it, and its
+// branch errors get the same treatment, so the shape does not depend on
+// which engine answered.
+const COLLAPSE_CODES = new Set(['ATA4001', 'ATA4002', 'ATA4003']);
 function stripOrdinal(e) {
-  if (e === null || typeof e !== 'object' || e._o === undefined) return e;
+  if (e === null || typeof e !== 'object') return e;
+  if (e._o === undefined && e.docUrl === undefined && (e.code === undefined || COLLAPSE_CODES.has(e.code)) && !e.branchErrors) return e;
   const out = {};
-  for (const k in e) if (k !== '_o') out[k] = e[k];
+  for (const k in e) {
+    if (k === '_o' || k === 'docUrl') continue;
+    if (k === 'code' && !COLLAPSE_CODES.has(e.code)) continue;
+    out[k] = k === 'branchErrors' && Array.isArray(e[k]) ? e[k].map(stripOrdinal) : e[k];
+  }
   return out;
 }
 
@@ -261,7 +273,33 @@ function stripOrdinal(e) {
 // place in the target (rankFor), so they come out in the order they would
 // inline, whichever engine produced them. Most rejections come out already
 // ordered, and those return without sorting or allocating.
+// A list of one can still hold a collapsed error whose branch errors, at any
+// depth, need ordering.
+function needsOrdering(raw) {
+  if (raw.length > 1) return true;
+  const e = raw[0];
+  return raw.length === 1 && e !== null && typeof e === 'object' && Array.isArray(e.branchErrors) && needsOrdering(e.branchErrors);
+}
+
+// A collapsed oneOf/anyOf error carries the closest branch's errors, which
+// each engine produces in its own walk order. They go in schema order like the
+// list they sit in, so which engine answered cannot be read off them.
+function sortBranchErrors(rootSchema, errors) {
+  let out = null;
+  for (let i = 0; i < errors.length; i++) {
+    const e = errors[i];
+    const b = e !== null && typeof e === 'object' ? e.branchErrors : undefined;
+    if (!Array.isArray(b) || b.length === 0) continue;
+    const sb = sortErrorsBySchemaOrder(rootSchema, b);
+    if (sb === b) continue;
+    if (out === null) out = errors.slice();
+    out[i] = Object.assign({}, e, { branchErrors: sb });
+  }
+  return out === null ? errors : out;
+}
+
 function sortErrorsBySchemaOrder(rootSchema, errors) {
+  errors = sortBranchErrors(rootSchema, errors);
   const n = errors.length;
   const keys = new Array(n);
   let sorted = true;