joi 11.3.2 → 12.0.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.2/API.md).
+See the detailed [API Reference](https://github.com/hapijs/joi/blob/v12.0.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;
@@ -116,7 +120,7 @@ exports.Err = class {
 
             const value = Hoek.reach(this.context, name);
             const normalized = internals.stringify(value, wrapArrays);
-            return (isSecure ? Hoek.escapeHtml(normalized) : normalized);
+            return (isSecure && this.options.escapeHtml ? Hoek.escapeHtml(normalized) : normalized);
         });
     }
 

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);
     }
@@ -47,12 +49,12 @@ internals.root = function () {
 
         Hoek.assert(arguments.length === 0, 'Joi.any() does not allow arguments.');
 
-        return internals.applyDefaults.call(this || root, any);
+        return internals.applyDefaults.call(this, any);
     };
 
     root.alternatives = root.alt = function () {
 
-        const alternatives = internals.applyDefaults.call(this || root, internals.alternatives);
+        const alternatives = internals.applyDefaults.call(this, internals.alternatives);
         return arguments.length ? alternatives.try.apply(alternatives, arguments) : alternatives;
     };
 
@@ -60,47 +62,47 @@ internals.root = function () {
 
         Hoek.assert(arguments.length === 0, 'Joi.array() does not allow arguments.');
 
-        return internals.applyDefaults.call(this || root, internals.array);
+        return internals.applyDefaults.call(this, internals.array);
     };
 
     root.boolean = root.bool = function () {
 
         Hoek.assert(arguments.length === 0, 'Joi.boolean() does not allow arguments.');
 
-        return internals.applyDefaults.call(this || root, internals.boolean);
+        return internals.applyDefaults.call(this, internals.boolean);
     };
 
     root.binary = function () {
 
         Hoek.assert(arguments.length === 0, 'Joi.binary() does not allow arguments.');
 
-        return internals.applyDefaults.call(this || root, internals.binary);
+        return internals.applyDefaults.call(this, internals.binary);
     };
 
     root.date = function () {
 
         Hoek.assert(arguments.length === 0, 'Joi.date() does not allow arguments.');
 
-        return internals.applyDefaults.call(this || root, internals.date);
+        return internals.applyDefaults.call(this, internals.date);
     };
 
     root.func = function () {
 
         Hoek.assert(arguments.length === 0, 'Joi.func() does not allow arguments.');
 
-        return internals.applyDefaults.call(this || root, internals.func);
+        return internals.applyDefaults.call(this, internals.func);
     };
 
     root.number = function () {
 
         Hoek.assert(arguments.length === 0, 'Joi.number() does not allow arguments.');
 
-        return internals.applyDefaults.call(this || root, internals.number);
+        return internals.applyDefaults.call(this, internals.number);
     };
 
     root.object = function () {
 
-        const object = internals.applyDefaults.call(this || root, internals.object);
+        const object = internals.applyDefaults.call(this, internals.object);
         return arguments.length ? object.keys.apply(object, arguments) : object;
     };
 
@@ -108,7 +110,7 @@ internals.root = function () {
 
         Hoek.assert(arguments.length === 0, 'Joi.string() does not allow arguments.');
 
-        return internals.applyDefaults.call(this || root, internals.string);
+        return internals.applyDefaults.call(this, internals.string);
     };
 
     root.ref = function () {
@@ -246,11 +248,10 @@ internals.root = function () {
         const extensions = Hoek.flatten(Array.prototype.slice.call(arguments));
         Hoek.assert(extensions.length > 0, 'You need to provide at least one extension');
 
-        const currentJoi = this || root;
-        currentJoi.assert(extensions, root.extensionsSchema);
+        this.assert(extensions, root.extensionsSchema);
 
-        const joi = Object.create(currentJoi.any());
-        Object.assign(joi, currentJoi);
+        const joi = Object.create(this.any());
+        Object.assign(joi, this);
 
         for (let i = 0; i < extensions.length; ++i) {
             let extension = extensions[i];
@@ -259,9 +260,9 @@ internals.root = function () {
                 extension = extension(joi);
             }
 
-            currentJoi.assert(extension, root.extensionSchema);
+            this.assert(extension, root.extensionSchema);
 
-            const base = (extension.base || currentJoi.any()).clone(); // Cloning because we're going to override language afterwards
+            const base = (extension.base || this.any()).clone(); // Cloning because we're going to override language afterwards
             const ctor = base.constructor;
             const type = class extends ctor { // eslint-disable-line no-loop-func
 
@@ -333,7 +334,7 @@ internals.root = function () {
                     const ruleArgs = rule.params ?
                         (rule.params instanceof Any ? rule.params._inner.children.map((k) => k.key) : Object.keys(rule.params)) :
                         [];
-                    const validateArgs = rule.params ? Cast.schema(currentJoi, rule.params) : null;
+                    const validateArgs = rule.params ? Cast.schema(this, rule.params) : null;
 
                     type.prototype[rule.name] = function () { // eslint-disable-line no-loop-func
 
@@ -396,7 +397,7 @@ internals.root = function () {
             const instance = new type();
             joi[extension.name] = function () {
 
-                return internals.applyDefaults.call(this || joi, instance);
+                return internals.applyDefaults.call(this, instance);
             };
         }
 

package/lib/schemas.js

@@ -20,5 +20,6 @@ exports.options = Joi.object({
     raw: Joi.boolean(),
     context: Joi.object(),
     strip: Joi.boolean(),
-    noDefaults: Joi.boolean()
+    noDefaults: Joi.boolean(),
+    escapeHtml: Joi.boolean()
 }).strict();

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

@@ -25,7 +25,8 @@ internals.defaults = {
     language: {},
     presence: 'optional',
     strip: false,
-    noDefaults: false
+    noDefaults: false,
+    escapeHtml: false
 
     // context: null
 };
@@ -385,7 +386,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 +395,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.2",
+  "version": "12.0.0",
   "homepage": "https://github.com/hapijs/joi",
   "repository": "git://github.com/hapijs/joi",
   "main": "lib/index.js",