valgen 7.0.0 → 7.0.1

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '7.0.0';
+export const version = '7.0.1';
 export const postValidation = Symbol('postValidation');
 export const preValidation = Symbol('preValidation');
 export const VALIDATE_METADATA = Symbol('VALIDATE_METADATA');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/rules/utility-rules/one-of.js

@@ -13,8 +13,21 @@ export function oneOf(rules, options) {
         let discriminator;
         let v;
         let passed = false;
-        // Mock fail method to prevent errors
-        context.fail = () => (passed = false);
+        // Every candidate failing is normal control flow here (that's how
+        // "try the next one" works), so a candidate's own context.fail must
+        // not throw or accumulate into the real error list. But swallowing it
+        // completely would hide the *reason* every candidate failed - including
+        // a genuine bug in a candidate rule, which would otherwise look
+        // identical to "the input just didn't match". So the mock still
+        // records the last failure's message, and it's reported directly as
+        // the final error (oneOf can only report one message anyway) instead
+        // of being discarded in favor of a generic one.
+        let lastFailMessage;
+        context.fail = (_rule, message) => {
+            passed = false;
+            lastFailMessage =
+                message instanceof Error ? message.message : String(message);
+        };
         for (i = 0; i < l; i++) {
             passed = true;
             if (Array.isArray(rules[i])) {
@@ -39,7 +52,16 @@ export function oneOf(rules, options) {
                     if (!passed)
                         continue;
                 }
-                catch {
+                catch (e) {
+                    // A discriminator/rule that throws directly (bypassing
+                    // context.fail entirely, e.g. a plain function rather than one
+                    // built with validator()) must still count as "this candidate
+                    // failed" - otherwise `passed` is left at its top-of-loop `true`
+                    // and, if this is the last candidate, oneOf would silently
+                    // return an unvalidated value instead of failing.
+                    passed = false;
+                    lastFailMessage =
+                        e?.message != null ? String(e.message) : String(e);
                     continue;
                 }
             }
@@ -51,14 +73,16 @@ export function oneOf(rules, options) {
                     if (passed)
                         break;
                 }
-                catch {
-                    //
+                catch (e) {
+                    passed = false;
+                    lastFailMessage =
+                        e?.message != null ? String(e.message) : String(e);
                 }
         }
         // Restore fail method
         delete context.fail;
         if (passed)
             return v;
-        context.fail(_this, `Value didn't match one of required rules`, input);
+        context.fail(_this, lastFailMessage || `Value didn't match one of required rules`, input);
     }, options);
 }