joi 14.1.0 → 14.3.1

package/README.md

@@ -16,7 +16,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/v14.1.0/API.md).
+See the detailed [API Reference](https://github.com/hapijs/joi/blob/v14.3.1/API.md).
 
 # Example
 
@@ -115,7 +115,7 @@ When validating a schema:
     ```
 
 * Strings are utf-8 encoded by default.
-* Rules are defined in an additive fashion and evaluated in order after whitelist and blacklist checks.
+* Rules are defined in an additive fashion and evaluated in order, first the inclusive rules, then the exclusive rules.
 
 # Browsers
 

package/lib/errors.js

@@ -106,7 +106,7 @@ exports.Err = class {
             return childrenString;
         }
 
-        const hasKey = /\{\{\!?label\}\}/.test(format);
+        const hasKey = /{{!?label}}/.test(format);
         const skipKey = format.length > 2 && format[0] === '!' && format[1] === '!';
 
         if (skipKey) {
@@ -123,7 +123,7 @@ exports.Err = class {
             }
         }
 
-        const message =  format.replace(/\{\{(\!?)([^}]+)\}\}/g, ($0, isSecure, name) => {
+        const message =  format.replace(/{{(!?)([^}]+)}}/g, ($0, isSecure, name) => {
 
             const value = Hoek.reach(this.context, name);
             const normalized = internals.stringify(value, wrapArrays);
@@ -165,7 +165,9 @@ exports.process = function (errors, object) {
             }
 
             if (item.flags.error && typeof item.flags.error !== 'function') {
-                return item.flags.error;
+                if (!item.flags.selfError || !item.context.reason) {
+                    return item.flags.error;
+                }
             }
 
             let itemMessage;
@@ -344,10 +346,10 @@ internals.annotate = function (stripColorCodes) {
     }
 
     const replacers = {
-        key: /_\$key\$_([, \d]+)_\$end\$_\"/g,
-        missing: /\"_\$miss\$_([^\|]+)\|(\d+)_\$end\$_\"\: \"__missing__\"/g,
-        arrayIndex: /\s*\"_\$idx\$_([, \d]+)_\$end\$_\",?\n(.*)/g,
-        specials: /"\[(NaN|Symbol.*|-?Infinity|function.*|\(.*)\]"/g
+        key: /_\$key\$_([, \d]+)_\$end\$_"/g,
+        missing: /"_\$miss\$_([^|]+)\|(\d+)_\$end\$_": "__missing__"/g,
+        arrayIndex: /\s*"_\$idx\$_([, \d]+)_\$end\$_",?\n(.*)/g,
+        specials: /"\[(NaN|Symbol.*|-?Infinity|function.*|\(.*)]"/g
     };
 
     let message = internals.safeStringify(obj, 2)

package/lib/index.js

@@ -46,6 +46,7 @@ internals.root = function () {
     const root = any.clone();
     Any.prototype._currentJoi = root;
     root._currentJoi = root;
+    root._binds = new Set(['any', 'alternatives', 'alt', 'array', 'boolean', 'binary', 'date', 'func', 'number', 'object', 'string', 'symbol', 'validate', 'describe', 'compile', 'assert', 'attempt', 'lazy', 'defaults', 'extend', 'allow', 'valid', 'only', 'equal', 'invalid', 'disallow', 'not', 'required', 'exist', 'optional', 'forbidden', 'strip', 'when', 'empty', 'default']);
 
     root.any = function (...args) {
 
@@ -141,14 +142,14 @@ internals.root = function () {
         }
 
         const options = count === 2 ? args[1] : undefined;
-        const schema = root.compile(args[0]);
+        const schema = this.compile(args[0]);
 
         return schema._validateWithOptions(value, options, callback);
     };
 
     root.describe = function (...args) {
 
-        const schema = args.length ? root.compile(args[0]) : any;
+        const schema = args.length ? this.compile(args[0]) : any;
         return schema.describe();
     };
 
@@ -168,12 +169,12 @@ internals.root = function () {
 
     root.assert = function (value, schema, message) {
 
-        root.attempt(value, schema, message);
+        this.attempt(value, schema, message);
     };
 
     root.attempt = function (value, schema, message) {
 
-        const result = root.validate(value, schema);
+        const result = this.validate(value, schema);
         const error = result.error;
         if (error) {
             if (!message) {
@@ -259,6 +260,18 @@ internals.root = function () {
         return joi;
     };
 
+    root.bind = function () {
+
+        const joi = Object.create(this);
+
+        joi._binds.forEach((bind) => {
+
+            joi[bind] = joi[bind].bind(joi);
+        });
+
+        return joi;
+    };
+
     root.extend = function (...args) {
 
         const extensions = Hoek.flatten(args);
@@ -268,6 +281,8 @@ internals.root = function () {
 
         const joi = Object.create(this.any());
         Object.assign(joi, this);
+        joi._currentJoi = joi;
+        joi._binds = new Set(joi._binds);
 
         for (let i = 0; i < extensions.length; ++i) {
             let extension = extensions[i];
@@ -416,6 +431,8 @@ internals.root = function () {
 
                 return internals.callWithDefaults.call(this, instance, extArgs);
             };
+
+            joi._binds.add(extension.name);
         }
 
         return joi;

package/lib/language.js

@@ -37,6 +37,8 @@ exports.errors = {
         includesRequiredBoth: 'does not contain {{knownMisses}} and {{unknownMisses}} other required value(s)',
         excludes: 'at position {{pos}} contains an excluded value',
         excludesSingle: 'single value of "{{!label}}" contains an excluded value',
+        hasKnown: 'does not contain at least one required match for type "{{!patternLabel}}"',
+        hasUnknown: 'does not contain at least one required match',
         min: 'must contain at least {{limit}} items',
         max: 'must contain less than or equal to {{limit}} items',
         length: 'must contain {{limit}} items',

package/lib/types/any/index.js

@@ -279,12 +279,20 @@ module.exports = internals.Any = class {
         return obj;
     }
 
-    error(err) {
+    error(err, options = { self: false }) {
 
         Hoek.assert(err && (err instanceof Error || typeof err === 'function'), 'Must provide a valid Error object or a function');
 
+        const unknownKeys = Object.keys(options).filter((k) => !['self'].includes(k));
+        Hoek.assert(unknownKeys.length === 0, `Options ${unknownKeys} are unknown`);
+
         const obj = this.clone();
         obj._flags.error = err;
+
+        if (options.self) {
+            obj._flags.selfError = true;
+        }
+
         return obj;
     }
 
@@ -715,7 +723,13 @@ module.exports = internals.Any = class {
             finalValue = Hoek.clone(this._flags.default);
         }
 
-        if (errors.length && typeof this._flags.error === 'function') {
+        if (errors.length &&
+            typeof this._flags.error === 'function' &&
+            (
+                !this._flags.selfError ||
+                errors.some((e) => state.path.length === e.path.length)
+            )
+        ) {
             const change = this._flags.error.call(this, errors);
 
             if (typeof change === 'string') {

package/lib/types/any/settings.js

@@ -24,8 +24,8 @@ exports.concat = function (target, source) {
 
     Object.assign(obj, source);
 
-    if (language) {
-        obj.language = Hoek.applyToDefaults(obj.language, language);
+    if (language && target && target.language) {
+        obj.language = Hoek.applyToDefaults(target.language, language);
     }
 
     if (obj[Symbols.settingsCache]) {

package/lib/types/array/index.js

@@ -332,6 +332,15 @@ internals.Array = class extends Any {
             }
         }
 
+        if (description.rules) {
+            for (let i = 0; i < description.rules.length; ++i) {
+                const rule = description.rules[i];
+                if (rule.name === 'has') {
+                    rule.arg = rule.arg.describe();
+                }
+            }
+        }
+
         return description;
     }
 
@@ -352,7 +361,7 @@ internals.Array = class extends Any {
                     castErr.path = index;
                 }
 
-                castErr.message = castErr.message + '(' + castErr.path + ')';
+                castErr.message = `${castErr.message}(${castErr.path})`;
                 throw castErr;
             }
 
@@ -389,7 +398,7 @@ internals.Array = class extends Any {
                     castErr.path = index;
                 }
 
-                castErr.message = castErr.message + '(' + castErr.path + ')';
+                castErr.message = `${castErr.message}(${castErr.path})`;
                 throw castErr;
             }
 
@@ -483,6 +492,40 @@ internals.Array = class extends Any {
         });
     }
 
+    has(schema) {
+
+        try {
+            schema = Cast.schema(this._currentJoi, schema);
+        }
+        catch (castErr) {
+            if (castErr.hasOwnProperty('path')) {
+                castErr.message = `${castErr.message}(${castErr.path})`;
+            }
+
+            throw castErr;
+        }
+
+        return this._test('has', schema, function (value, state, options) {
+
+            const isValid = value.some((item, idx) => {
+
+                const localState = new State(idx, [...state.path, idx], state.key, state.reference);
+                return !schema._validate(item, localState, options).errors;
+            });
+
+            if (isValid) {
+                return value;
+            }
+
+            const patternLabel = schema._getLabel();
+            if (patternLabel) {
+                return this.createError('array.hasKnown', { patternLabel }, state, options);
+            }
+
+            return this.createError('array.hasUnknown', null, state, options);
+        });
+    }
+
     unique(comparator, configs) {
 
         Hoek.assert(comparator === undefined ||

package/lib/types/object/index.js

@@ -308,7 +308,7 @@ internals.Object = class extends Any {
             const hasKey = dep.key !== null;
             const splitKey = hasKey && dep.key.split('.');
             const localState = hasKey ? new State(splitKey[splitKey.length - 1], [...state.path, ...splitKey]) : new State(null, state.path);
-            const err = internals[dep.type].call(this, dep.key, hasKey && Hoek.reach(target, dep.key), dep.peers, target, localState, options);
+            const err = internals[dep.type].call(this, dep.key, hasKey && Hoek.reach(target, dep.key, { functions: true }), dep.peers, target, localState, options);
             if (err instanceof Errors.Err) {
                 errors.push(err);
                 if (options.abortEarly) {
@@ -454,7 +454,7 @@ internals.Object = class extends Any {
         }
         catch (castErr) {
             if (castErr.hasOwnProperty('path')) {
-                castErr.message = castErr.message + '(' + castErr.path + ')';
+                castErr.message = `${castErr.message}(${castErr.path})`;
             }
 
             throw castErr;
@@ -686,7 +686,7 @@ internals.Object = class extends Any {
         }
         catch (castErr) {
             if (castErr.hasOwnProperty('path')) {
-                castErr.message = castErr.message + '(' + castErr.path + ')';
+                castErr.message = `${castErr.message}(${castErr.path})`;
             }
 
             throw castErr;
@@ -793,7 +793,7 @@ internals.with = function (key, value, peers, parent, state, options) {
     for (let i = 0; i < peers.length; ++i) {
 
         const peer = peers[i];
-        const keysExist = Hoek.reach(parent, peer);
+        const keysExist = Hoek.reach(parent, peer, { functions: true });
         if (keysExist === undefined) {
 
             return this.createError('object.with', {
@@ -815,7 +815,7 @@ internals.without = function (key, value, peers, parent, state, options) {
 
     for (let i = 0; i < peers.length; ++i) {
         const peer = peers[i];
-        const keysExist = Hoek.reach(parent, peer);
+        const keysExist = Hoek.reach(parent, peer, { functions: true });
         if (keysExist !== undefined) {
 
             return this.createError('object.without', {
@@ -834,7 +834,7 @@ internals.xor = function (key, value, peers, parent, state, options) {
     const present = [];
     for (let i = 0; i < peers.length; ++i) {
         const peer = peers[i];
-        const keysExist = Hoek.reach(parent, peer);
+        const keysExist = Hoek.reach(parent, peer, { functions: true });
         if (keysExist !== undefined) {
             present.push(peer);
         }
@@ -862,7 +862,7 @@ internals.oxor = function (key, value, peers, parent, state, options) {
     const present = [];
     for (let i = 0; i < peers.length; ++i) {
         const peer = peers[i];
-        const keysExist = Hoek.reach(parent, peer);
+        const keysExist = Hoek.reach(parent, peer, { functions: true });
         if (keysExist !== undefined) {
             present.push(peer);
         }
@@ -886,7 +886,7 @@ internals.or = function (key, value, peers, parent, state, options) {
 
     for (let i = 0; i < peers.length; ++i) {
         const peer = peers[i];
-        const keysExist = Hoek.reach(parent, peer);
+        const keysExist = Hoek.reach(parent, peer, { functions: true });
         if (keysExist !== undefined) {
             return;
         }
@@ -906,7 +906,7 @@ internals.and = function (key, value, peers, parent, state, options) {
     const count = peers.length;
     for (let i = 0; i < count; ++i) {
         const peer = peers[i];
-        const keysExist = Hoek.reach(parent, peer);
+        const keysExist = Hoek.reach(parent, peer, { functions: true });
         if (keysExist === undefined) {
 
             missing.push(peer);
@@ -935,7 +935,7 @@ internals.nand = function (key, value, peers, parent, state, options) {
     const present = [];
     for (let i = 0; i < peers.length; ++i) {
         const peer = peers[i];
-        const keysExist = Hoek.reach(parent, peer);
+        const keysExist = Hoek.reach(parent, peer, { functions: true });
         if (keysExist !== undefined) {
 
             present.push(peer);

package/package.json

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