@jarenjs/validate 0.9.2 → 0.34.2

package/src/combine.js

@@ -10,6 +10,7 @@ import {
 } from '@jarenjs/core/function';
 
 import {
+  combineIndependent,
   getBoolOrObjectClass,
   getArrayClassMinItems,
 } from './tools.js';
@@ -34,14 +35,20 @@ function compileAllOf(schemaObj, jsonSchema) {
 
   const addError = schemaObj.createErrorHandler(allOf, 'allOf');
 
+  const stopAtFirst = schemaObj.options.skipErrors;
   return function validateAllOf(data, dataPath, dataRoot, dataKey) {
     if (data !== undefined) {
+      // EVERY allOf branch applies, so every branch's faults are real. Only
+      // the boolean answer may stop at the first failing branch.
+      let valid = true;
       for (let i = 0; i < validators.length; ++i) {
         const validator = validators[i];
         if (validator(data, dataPath, dataRoot, dataKey) === false) {
-          return addError(data, dataPath);
+          valid = addError(data, dataPath);
+          if (stopAtFirst) return valid;
         }
       }
+      return valid;
     }
     return true;
   };
@@ -75,6 +82,7 @@ function compileAnyOf(schemaObj, jsonSchema) {
     return function validateAnyOfTracked(data, dataPath, dataRoot, dataKey) {
       if (data === undefined) return true;
       const log = root.evalLog;
+      const errors = root.errorMark();
       let found = false;
       for (let i = 0; i < validators.length; ++i) {
         const mark = log.mark();
@@ -83,15 +91,24 @@ function compileAnyOf(schemaObj, jsonSchema) {
         else
           log.rollback(mark);
       }
+      // Annotation tracking runs every branch, so a match leaves the failed
+      // branches' errors behind unless they are rolled back here too.
+      if (found) root.rollbackErrors(errors);
       return found || addError(data, dataPath);
     };
   }
 
   return function validateAnyOf(data, dataPath, dataRoot, dataKey) {
     if (data !== undefined) {
+      // Every branch tried before a match is a SPECULATIVE probe: the document
+      // was never required to satisfy it. Its errors are kept only if no
+      // branch matched at all, where they are the explanation.
+      const mark = root.errorMark();
       for (let i = 0; i < validators.length; ++i) {
-        const validator = validators[i]; // TODO: how to silence errors of children?
-        if (validator(data, dataPath, dataRoot, dataKey) === true) return true;
+        if (validators[i](data, dataPath, dataRoot, dataKey) === true) {
+          root.rollbackErrors(mark);
+          return true;
+        }
       }
       return addError(data, dataPath);
     }
@@ -126,32 +143,43 @@ function compileOneOf(schemaObj, jsonSchema) {
   if (root.usesUnevaluated) {
     return function validateOneOfTracked(data, dataPath, dataRoot, dataKey) {
       const log = root.evalLog;
+      const errors = root.errorMark();
       let found = false;
       for (let i = 0; i < validators.length; ++i) {
         const mark = log.mark();
         if (validators[i](data, dataPath, dataRoot, dataKey) === true) {
-          if (found === true)
+          if (found === true) {
+            root.rollbackErrors(errors);
             return addError(data, dataPath);
+          }
           found = true;
         }
         else {
           log.rollback(mark);
         }
       }
+      // Non-matching branches were speculative; their complaints survive only
+      // when nothing matched and they are the explanation.
+      if (found) root.rollbackErrors(errors);
       return found || addError(data, dataPath);
     };
   }
 
   return function validateOneOf(data, dataPath, dataRoot, dataKey) {
+    const errors = root.errorMark();
     let found = false;
     for (let i = 0; i < validators.length; ++i) {
-      const validator = validators[i];
-      if (validator(data, dataPath, dataRoot, dataKey) === true) {
-        if (found === true)
+      if (validators[i](data, dataPath, dataRoot, dataKey) === true) {
+        if (found === true) {
+          // Matching twice is the failure; the branches' own errors explain
+          // nothing about it.
+          root.rollbackErrors(errors);
           return addError(data, dataPath);
+        }
         found = true;
       }
     }
+    if (found) root.rollbackErrors(errors);
     return found || addError(data, dataPath);
   };
 }
@@ -159,13 +187,21 @@ function compileOneOf(schemaObj, jsonSchema) {
 function compileNotOf(schemaObj, jsonSchema) {
   const notOf = getBoolOrObjectClass(jsonSchema.not);
   if (notOf == null) return undefined;
-  if (notOf === true) return falseThat;
   if (notOf === false) return trueThat;
 
-  const validate = schemaObj.createValidator(notOf, 'not');
-
   const addError = schemaObj.createErrorHandler(notOf, 'not');
 
+  // `not: true` rejects every instance. It still has to SAY so: returning a
+  // bare false made the only schema that can fail without explanation, and a
+  // collector that reports "invalid" with an empty error list is unusable by
+  // a caller trying to render why.
+  if (notOf === true)
+    return function validateNotOfTrue(data, dataPath) {
+      return data === undefined ? true : addError(data, dataPath);
+    };
+
+  const validate = schemaObj.createValidator(notOf, 'not');
+
   // Annotations produced inside a 'not' are never kept, whatever the outcome.
   const root = schemaObj.root;
   if (root.usesUnevaluated) {
@@ -173,8 +209,12 @@ function compileNotOf(schemaObj, jsonSchema) {
       if (data === undefined) return true;
       const log = root.evalLog;
       const mark = log.mark();
+      const errors = root.errorMark();
       const valid = validate(data, dataPath, dataRoot, dataKey);
       log.rollback(mark);
+      // A `not` whose subschema FAILS is a `not` that passed, so the
+      // subschema's complaints are never the caller's business either way.
+      root.rollbackErrors(errors);
       return valid === false
         ? true
         : addError(data, dataPath);
@@ -183,7 +223,12 @@ function compileNotOf(schemaObj, jsonSchema) {
 
   return function validateNotOf(data, dataPath, dataRoot, dataKey) {
     if (data === undefined) return true;
-    return validate(data, dataPath, dataRoot, dataKey) === false
+    // The subschema is a probe: its failure is what makes `not` succeed, so
+    // its errors are discarded whichever way the probe went.
+    const errors = root.errorMark();
+    const valid = validate(data, dataPath, dataRoot, dataKey);
+    root.rollbackErrors(errors);
+    return valid === false
       ? true
       : addError(data, dataPath);
   };
@@ -205,6 +250,11 @@ export function compileCombineSchema(schemaObj, jsonSchema) {
     return undefined;
   if (validators.length === 1)
     return validators[0];
+  // allOf/anyOf/oneOf/not are independent applicator groups: a failing
+  // `oneOf` says nothing about whether `not` also failed.
+  if (!schemaObj.options.skipErrors)
+    return combineIndependent(validators);
+
   if (validators.length === 2) {
     const first = validators[0];
     const second = validators[1];

package/src/condition.js

@@ -27,8 +27,13 @@ export function compileConditionSchema(schemaObj, jsonSchema) {
       return function validateLoneIf(data, dataPath, dataRoot, dataKey) {
         const log = root.evalLog;
         const mark = log.mark();
+        // A lone `if` asserts NOTHING, so it can never explain a failure and
+        // its errors are always discarded. Only its annotations survive, and
+        // only when it passed.
+        const errors = root.errorMark();
         if (validateIf(data, dataPath, dataRoot, dataKey) === false)
           log.rollback(mark);
+        root.rollbackErrors(errors);
         return true;
       };
     }
@@ -56,9 +61,13 @@ export function compileConditionSchema(schemaObj, jsonSchema) {
     return function validateConditionTracked(data, dataPath, dataRoot, dataKey) {
       const log = root.evalLog;
       const mark = log.mark();
-      if (validateIf(data, dataPath, dataRoot, dataKey)) {
-        return validateThen(data, dataPath, dataRoot, dataKey);
-      }
+      // `if` decides WHICH branch applies; the document was never required to
+      // satisfy it, so its complaints are discarded either way. Only `then`
+      // and `else` produce errors a caller should see.
+      const errors = root.errorMark();
+      const taken = validateIf(data, dataPath, dataRoot, dataKey);
+      root.rollbackErrors(errors);
+      if (taken) return validateThen(data, dataPath, dataRoot, dataKey);
       log.rollback(mark);
       return validateElse(data, dataPath, dataRoot, dataKey);
     };
@@ -66,30 +75,41 @@ export function compileConditionSchema(schemaObj, jsonSchema) {
 
   // If neither then nor else has dynamic anchors, use simple validation
   if (!thenHasAnchor && !elseHasAnchor) {
-    return function validateCondition(data, dataRoot) {
-      if (validateIf(data))
-        return validateThen(data, dataRoot);
-      else
-        return validateElse(data, dataRoot);
+    // Every call site passes (data, dataPath, dataRoot, dataKey). Declaring
+    // fewer parameters does not drop the extra arguments, it MISBINDS them:
+    // a two-parameter form named its second parameter `dataRoot` and was
+    // handed the dataPath, so the branch validators ran with no root at all
+    // and a `$data` reference inside `then` silently resolved to nothing —
+    // a wrong verdict rather than an error.
+    return function validateCondition(data, dataPath, dataRoot, dataKey) {
+      const errors = root.errorMark();
+      const taken = validateIf(data, dataPath, dataRoot, dataKey);
+      root.rollbackErrors(errors);
+      return taken
+        ? validateThen(data, dataPath, dataRoot, dataKey)
+        : validateElse(data, dataPath, dataRoot, dataKey);
     };
   }
   
   // If then or else has dynamic anchors, wrap validation to register them
   const track = root.usesUnevaluated;
-  return function validateConditionWithDynamicAnchors(data, dataPath, dataRoot) {
+  return function validateConditionWithDynamicAnchors(data, dataPath, dataRoot, dataKey) {
     const mark = track ? root.evalLog.mark() : 0;
-    if (validateIf(data)) {
+    const conditionErrors = root.errorMark();
+    const taken = validateIf(data, dataPath, dataRoot, dataKey);
+    root.rollbackErrors(conditionErrors);
+    if (taken) {
       // Validate then branch with dynamic anchor registration
       if (thenHasAnchor && tmpThen) {
         const anchorName = thenDynAnchorName || '';
         root.pushDynamicAnchorValidator(anchorName, tmpThen);
         try {
-          return validateThen(data, dataRoot);
+          return validateThen(data, dataPath, dataRoot, dataKey);
         } finally {
           root.popDynamicAnchorValidator(anchorName);
         }
       }
-      return validateThen(data, dataRoot);
+      return validateThen(data, dataPath, dataRoot, dataKey);
     } else {
       // Annotations from the failed 'if' must not leak to unevaluated*
       if (track) root.evalLog.rollback(mark);
@@ -98,12 +118,12 @@ export function compileConditionSchema(schemaObj, jsonSchema) {
         const anchorName = elseDynAnchorName || '';
         root.pushDynamicAnchorValidator(anchorName, tmpElse);
         try {
-          return validateElse(data, dataRoot);
+          return validateElse(data, dataPath, dataRoot, dataKey);
         } finally {
           root.popDynamicAnchorValidator(anchorName);
         }
       }
-      return validateElse(data, dataRoot);
+      return validateElse(data, dataPath, dataRoot, dataKey);
     }
   };
 }

package/src/content.js

@@ -4,7 +4,7 @@ import {
 } from '@jarenjs/core';
 
 import {
-  isValidBase64Fast,
+  isValidBase64,
 } from '@jarenjs/core/text';
 
 import {
@@ -21,7 +21,7 @@ export function compileContentEncoding(schemaObj, jsonSchema) {
     return function validateBase64(data, dataPath) {
       // contentEncoding only applies to strings - ignore non-strings
       if (!isStringType(data)) return true;
-      return isValidBase64Fast(data)
+      return isValidBase64(data)
         || addError(data, dataPath);
     };
   }
@@ -50,7 +50,7 @@ export function compileContentMediaType(schemaObj, jsonSchema) {
       return function validateBase64JsonContent(data, dataPath) {
         if (!isStringType(data)) return true;
         // Check valid base64 first before decoding
-        if (!isValidBase64Fast(data)) return addError(data, dataPath);
+        if (!isValidBase64(data)) return addError(data, dataPath);
         const decoded = Buffer.from(data, 'base64').toString('utf8');
         return isValidJSON(decoded) || addError(data, dataPath);
       }