joi 11.3.0 → 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.0/API.md).
+See the detailed [API Reference](https://github.com/hapijs/joi/blob/v11.4.0/API.md).
 
 # Example
 

package/lib/errors.js

@@ -88,6 +88,10 @@ exports.Err = class {
 
         format = format || Hoek.reach(localized, this.type) || Hoek.reach(Language.errors, this.type);
 
+        if (format === undefined) {
+            return `Error code "${this.type}" is not defined, your custom type is missing the correct language definition`;
+        }
+
         let wrapArrays = Hoek.reach(localized, 'messages.wrapArrays');
         if (typeof wrapArrays !== 'boolean') {
             wrapArrays = Language.errors.messages.wrapArrays;

package/lib/index.js

@@ -26,6 +26,8 @@ const internals = {
 
 internals.applyDefaults = function (schema) {
 
+    Hoek.assert(this, 'Must be invoked on a Joi instance.');
+
     if (this._defaults) {
         schema = this._defaults(schema);
     }

package/lib/language.js

@@ -97,7 +97,11 @@ exports.errors = {
         assert: '!!"{{ref}}" validation failed because "{{ref}}" failed to {{message}}',
         rename: {
             multiple: 'cannot rename child "{{from}}" because multiple renames are disabled and another key was already renamed to "{{to}}"',
-            override: 'cannot rename child "{{from}}" because override is disabled and target "{{to}}" exists'
+            override: 'cannot rename child "{{from}}" because override is disabled and target "{{to}}" exists',
+            regex: {
+                multiple: 'cannot rename children {{from}} because multiple renames are disabled and another key was already renamed to "{{to}}"',
+                override: 'cannot rename children {{from}} because override is disabled and target "{{to}}" exists'
+            }
         },
         type: 'must be an instance of "{{type}}"',
         schema: 'must be a Joi instance'

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/lib/types/object/index.js

@@ -112,7 +112,7 @@ internals.Object = class extends Any {
                 if (!rename.options.multiple &&
                     renamed[rename.to]) {
 
-                    errors.push(this.createError('object.rename.multiple', { from: matchedTargetKeys, to: rename.to }, state, options));
+                    errors.push(this.createError('object.rename.regex.multiple', { from: matchedTargetKeys, to: rename.to }, state, options));
                     if (options.abortEarly) {
                         return finish();
                     }
@@ -122,7 +122,7 @@ internals.Object = class extends Any {
                     !rename.options.override &&
                     !renamed[rename.to]) {
 
-                    errors.push(this.createError('object.rename.override', { from: rename.from, to: rename.to }, state, options));
+                    errors.push(this.createError('object.rename.regex.override', { from: matchedTargetKeys, to: rename.to }, state, options));
                     if (options.abortEarly) {
                         return finish();
                     }

package/package.json

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