joi 11.3.4 → 11.4.0

package/README.md

@@ -26,7 +26,7 @@ Imagine you run facebook and you want visitors to sign up on the website with re
 This is joi, joi allows you to create *blueprints* or *schemas* for JavaScript objects (an object that stores information) to ensure *validation* of key information.
 
 # API
-See the detailed [API Reference](https://github.com/hapijs/joi/blob/v11.3.4/API.md).
+See the detailed [API Reference](https://github.com/hapijs/joi/blob/v11.4.0/API.md).
 
 # Example
 

package/lib/types/alternatives/index.js

@@ -31,9 +31,10 @@ internals.Alternatives = class extends Any {
 
         for (let i = 0; i < il; ++i) {
             const item = this._inner.matches[i];
-            const schema = item.schema;
-            if (!schema) {
-                const failed = item.is._validate(item.ref(state.reference || state.parent, options), null, options, state.parent).errors;
+            if (!item.schema) {
+                const schema = item.peek || item.is;
+                const input = item.is ? item.ref(state.reference || state.parent, options) : value;
+                const failed = schema._validate(input, null, options, state.parent).errors;
 
                 if (failed) {
                     if (item.otherwise) {
@@ -51,7 +52,7 @@ internals.Alternatives = class extends Any {
                 continue;
             }
 
-            const result = schema._validate(value, state, options);
+            const result = item.schema._validate(value, state, options);
             if (!result.errors) {     // Found a valid match
                 return result;
             }
@@ -84,25 +85,35 @@ internals.Alternatives = class extends Any {
         return obj;
     }
 
-    when(ref, options) {
+    when(condition, options) {
 
-        Hoek.assert(Ref.isRef(ref) || typeof ref === 'string', 'Invalid reference:', ref);
+        let schemaCondition = false;
+        Hoek.assert(Ref.isRef(condition) || typeof condition === 'string' || (schemaCondition = condition instanceof Any), 'Invalid condition:', condition);
         Hoek.assert(options, 'Missing options');
         Hoek.assert(typeof options === 'object', 'Invalid options');
-        Hoek.assert(options.hasOwnProperty('is'), 'Missing "is" directive');
+        if (schemaCondition) {
+            Hoek.assert(!options.hasOwnProperty('is'), '"is" can not be used with a schema condition');
+        }
+        else {
+            Hoek.assert(options.hasOwnProperty('is'), 'Missing "is" directive');
+        }
         Hoek.assert(options.then !== undefined || options.otherwise !== undefined, 'options must have at least one of "then" or "otherwise"');
 
         const obj = this.clone();
-        let is = Cast.schema(this._currentJoi, options.is);
+        let is;
+        if (!schemaCondition) {
+            is = Cast.schema(this._currentJoi, options.is);
 
-        if (options.is === null || !(Ref.isRef(options.is) || options.is instanceof Any)) {
+            if (options.is === null || !(Ref.isRef(options.is) || options.is instanceof Any)) {
 
-            // Only apply required if this wasn't already a schema or a ref, we'll suppose people know what they're doing
-            is = is.required();
+                // Only apply required if this wasn't already a schema or a ref, we'll suppose people know what they're doing
+                is = is.required();
+            }
         }
 
         const item = {
-            ref: Cast.ref(ref),
+            ref: schemaCondition ? null : Cast.ref(condition),
+            peek: schemaCondition ? condition : null,
             is,
             then: options.then !== undefined ? Cast.schema(this._currentJoi, options.then) : undefined,
             otherwise: options.otherwise !== undefined ? Cast.schema(this._currentJoi, options.otherwise) : undefined
@@ -114,8 +125,10 @@ internals.Alternatives = class extends Any {
             item.otherwise = item.otherwise && obj._baseType.concat(item.otherwise);
         }
 
-        Ref.push(obj._refs, item.ref);
-        obj._refs = obj._refs.concat(item.is._refs);
+        if (!schemaCondition) {
+            Ref.push(obj._refs, item.ref);
+            obj._refs = obj._refs.concat(item.is._refs);
+        }
 
         if (item.then && item.then._refs) {
             obj._refs = obj._refs.concat(item.then._refs);
@@ -146,9 +159,11 @@ internals.Alternatives = class extends Any {
 
                 // when()
 
-                const when = {
+                const when = item.is ? {
                     ref: item.ref.toString(),
                     is: item.is.describe()
+                } : {
+                    peek: item.peek.describe()
                 };
 
                 if (item.then) {

package/lib/types/any/index.js

@@ -385,7 +385,7 @@ module.exports = internals.Any = class {
         return obj;
     }
 
-    when(ref, options) {
+    when(condition, options) {
 
         Hoek.assert(options && typeof options === 'object', 'Invalid options');
         Hoek.assert(options.then !== undefined || options.otherwise !== undefined, 'options must have at least one of "then" or "otherwise"');
@@ -394,7 +394,12 @@ module.exports = internals.Any = class {
         const otherwise = options.hasOwnProperty('otherwise') ? this.concat(Cast.schema(this._currentJoi, options.otherwise)) : undefined;
 
         Alternatives = Alternatives || require('../alternatives');
-        const obj = Alternatives.when(ref, { is: options.is, then, otherwise });
+
+        const alternativeOptions = { then, otherwise };
+        if (Object.prototype.hasOwnProperty.call(options, 'is')) {
+            alternativeOptions.is = options.is;
+        }
+        const obj = Alternatives.when(condition, alternativeOptions);
         obj._flags.presence = 'ignore';
         obj._baseType = this;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "joi",
   "description": "Object schema validation",
-  "version": "11.3.4",
+  "version": "11.4.0",
   "homepage": "https://github.com/hapijs/joi",
   "repository": "git://github.com/hapijs/joi",
   "main": "lib/index.js",