joi 10.4.2 → 10.6.0

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012-2016, Project contributors
+Copyright (c) 2012-2017, Project contributors
 Copyright (c) 2012-2014, Walmart
 All rights reserved.
 

package/README.md

@@ -125,7 +125,7 @@ When validating a schema:
 * Rules are defined in an additive fashion and evaluated in order after whitelist and blacklist checks.
 
 # API
-See the [API Reference](https://github.com/hapijs/joi/blob/v10.4.2/API.md).
+See the [API Reference](https://github.com/hapijs/joi/blob/v10.6.0/API.md).
 
 # Browsers
 

package/lib/cast.js

@@ -12,10 +12,10 @@ const Ref = require('./ref');
 
 const internals = {
     any: null,
-    date: require('./date'),
-    string: require('./string'),
-    number: require('./number'),
-    boolean: require('./boolean'),
+    date: require('./types/date'),
+    string: require('./types/string'),
+    number: require('./types/number'),
+    boolean: require('./types/boolean'),
     alt: null,
     object: null
 };
@@ -23,9 +23,9 @@ const internals = {
 
 exports.schema = function (config) {
 
-    internals.any = internals.any || new (require('./any'))();
-    internals.alt = internals.alt || require('./alternatives');
-    internals.object = internals.object || require('./object');
+    internals.any = internals.any || new (require('./types/any'))();
+    internals.alt = internals.alt || require('./types/alternatives');
+    internals.object = internals.object || require('./types/object');
 
     if (config !== undefined && config !== null && typeof config === 'object') {
 

package/lib/errors.js

@@ -301,11 +301,13 @@ internals.annotate = function (stripColorCodes) {
             const seg = path[j];
 
             if (ref.isImmutable) {
-                // Joi schemas are not cloned by hoek, we have to take this extra step
-                ref = ref.clone();
+                ref = ref.clone();                              // joi schemas are not cloned by hoek, we have to take this extra step
             }
 
-            if (j + 1 < path.length && typeof ref[seg] !== 'string') {
+            if (j + 1 < path.length &&
+                ref[seg] &&
+                typeof ref[seg] !== 'string') {
+
                 ref = ref[seg];
             }
             else {

package/lib/index.js

@@ -3,24 +3,24 @@
 // Load modules
 
 const Hoek = require('hoek');
-const Any = require('./any');
+const Any = require('./types/any');
 const Cast = require('./cast');
 const Errors = require('./errors');
-const Lazy = require('./lazy');
+const Lazy = require('./types/lazy');
 const Ref = require('./ref');
 
 
 // Declare internals
 
 const internals = {
-    alternatives: require('./alternatives'),
-    array: require('./array'),
-    boolean: require('./boolean'),
-    binary: require('./binary'),
-    date: require('./date'),
-    number: require('./number'),
-    object: require('./object'),
-    string: require('./string')
+    alternatives: require('./types/alternatives'),
+    array: require('./types/array'),
+    boolean: require('./types/boolean'),
+    binary: require('./types/binary'),
+    date: require('./types/date'),
+    number: require('./types/number'),
+    object: require('./types/object'),
+    string: require('./types/string')
 };
 
 
@@ -330,7 +330,11 @@ internals.root = function () {
                         }
 
                         if (rule.setup) {
-                            rule.setup.call(schema, arg);
+                            const newSchema = rule.setup.call(schema, arg);
+                            if (newSchema !== undefined) {
+                                Hoek.assert(newSchema instanceof Any, `Setup of extension Joi.${this._type}().${rule.name}() must return undefined or a Joi object`);
+                                schema = newSchema;
+                            }
                         }
 
                         return schema;

package/lib/language.js

@@ -42,6 +42,7 @@ exports.errors = {
         length: 'must contain {{limit}} items',
         ordered: 'at position {{pos}} fails because {{reason}}',
         orderedLength: 'at position {{pos}} fails because array must contain at most {{limit}} items',
+        ref: 'references "{{ref}}" which is not a positive integer',
         sparse: 'must not be a sparse array',
         unique: 'position {{pos}} contains a duplicate value'
     },

package/lib/{alternatives.js → types/alternatives/index.js}

@@ -3,9 +3,9 @@
 // Load modules
 
 const Hoek = require('hoek');
-const Any = require('./any');
-const Cast = require('./cast');
-const Ref = require('./ref');
+const Any = require('../any');
+const Cast = require('../../cast');
+const Ref = require('../../ref');
 
 
 // Declare internals

package/lib/{any.js → types/any/index.js}

@@ -3,8 +3,8 @@
 // Load modules
 
 const Hoek = require('hoek');
-const Ref = require('./ref');
-const Errors = require('./errors');
+const Ref = require('../../ref');
+const Errors = require('../../errors');
 let Alternatives = null;                // Delay-loaded to prevent circular dependencies
 let Cast = null;
 
@@ -12,7 +12,7 @@ let Cast = null;
 // Declare internals
 
 const internals = {
-    Set: require('./set')
+    Set: require('../../set')
 };
 
 
@@ -35,7 +35,7 @@ module.exports = internals.Any = class {
 
     constructor() {
 
-        Cast = Cast || require('./cast');
+        Cast = Cast || require('../../cast');
 
         this.isJoi = true;
         this._type = 'any';
@@ -83,7 +83,7 @@ module.exports = internals.Any = class {
 
     checkOptions(options) {
 
-        const Schemas = require('./schemas');
+        const Schemas = require('../../schemas');
         const result = Schemas.options.validate(options);
         if (result.error) {
             throw new Error(result.error.details[0].message);
@@ -381,7 +381,7 @@ module.exports = internals.Any = class {
         const then = options.hasOwnProperty('then') ? this.concat(Cast.schema(options.then)) : undefined;
         const otherwise = options.hasOwnProperty('otherwise') ? this.concat(Cast.schema(options.otherwise)) : undefined;
 
-        Alternatives = Alternatives || require('./alternatives');
+        Alternatives = Alternatives || require('../alternatives');
         const obj = Alternatives.when(ref, { is: options.is, then, otherwise });
         obj._flags.presence = 'ignore';
         obj._baseType = this;

package/lib/{array.js → types/array/index.js}

@@ -2,8 +2,9 @@
 
 // Load modules
 
-const Any = require('./any');
-const Cast = require('./cast');
+const Any = require('../any');
+const Cast = require('../../cast');
+const Ref = require('../../ref');
 const Hoek = require('hoek');
 
 
@@ -390,11 +391,25 @@ internals.Array = class extends Any {
 
     min(limit) {
 
-        Hoek.assert(Number.isSafeInteger(limit) && limit >= 0, 'limit must be a positive integer');
+        const isRef = Ref.isRef(limit);
+
+        Hoek.assert((Number.isSafeInteger(limit) && limit >= 0) || isRef, 'limit must be a positive integer or reference');
 
         return this._test('min', limit, function (value, state, options) {
 
-            if (value.length >= limit) {
+            let compareTo;
+            if (isRef) {
+                compareTo = limit(state.reference || state.parent, options);
+
+                if (!(Number.isSafeInteger(compareTo) && compareTo >= 0)) {
+                    return this.createError('array.ref', { ref: limit.key }, state, options);
+                }
+            }
+            else {
+                compareTo = limit;
+            }
+
+            if (value.length >= compareTo) {
                 return value;
             }
 
@@ -404,11 +419,25 @@ internals.Array = class extends Any {
 
     max(limit) {
 
-        Hoek.assert(Number.isSafeInteger(limit) && limit >= 0, 'limit must be a positive integer');
+        const isRef = Ref.isRef(limit);
+
+        Hoek.assert((Number.isSafeInteger(limit) && limit >= 0) || isRef, 'limit must be a positive integer or reference');
 
         return this._test('max', limit, function (value, state, options) {
 
-            if (value.length <= limit) {
+            let compareTo;
+            if (isRef) {
+                compareTo = limit(state.reference || state.parent, options);
+
+                if (!(Number.isSafeInteger(compareTo) && compareTo >= 0)) {
+                    return this.createError('array.ref', { ref: limit.key }, state, options);
+                }
+            }
+            else {
+                compareTo = limit;
+            }
+
+            if (value.length <= compareTo) {
                 return value;
             }
 
@@ -418,11 +447,25 @@ internals.Array = class extends Any {
 
     length(limit) {
 
-        Hoek.assert(Number.isSafeInteger(limit) && limit >= 0, 'limit must be a positive integer');
+        const isRef = Ref.isRef(limit);
+
+        Hoek.assert((Number.isSafeInteger(limit) && limit >= 0) || isRef, 'limit must be a positive integer or reference');
 
         return this._test('length', limit, function (value, state, options) {
 
-            if (value.length === limit) {
+            let compareTo;
+            if (isRef) {
+                compareTo = limit(state.reference || state.parent, options);
+
+                if (!(Number.isSafeInteger(compareTo) && compareTo >= 0)) {
+                    return this.createError('array.ref', { ref: limit.key }, state, options);
+                }
+            }
+            else {
+                compareTo = limit;
+            }
+
+            if (value.length === compareTo) {
                 return value;
             }
 

package/lib/{binary.js → types/binary/index.js}

@@ -2,7 +2,7 @@
 
 // Load modules
 
-const Any = require('./any');
+const Any = require('../any');
 const Hoek = require('hoek');
 
 

package/lib/{boolean.js → types/boolean/index.js}

@@ -2,14 +2,14 @@
 
 // Load modules
 
-const Any = require('./any');
+const Any = require('../any');
 const Hoek = require('hoek');
 
 
 // Declare internals
 
 const internals = {
-    Set: require('./set')
+    Set: require('../../set')
 };
 
 

package/lib/{date.js → types/date/index.js}

@@ -2,8 +2,8 @@
 
 // Load modules
 
-const Any = require('./any');
-const Ref = require('./ref');
+const Any = require('../any');
+const Ref = require('../../ref');
 const Hoek = require('hoek');
 
 

package/lib/{lazy.js → types/lazy/index.js}

@@ -2,7 +2,7 @@
 
 // Load modules
 
-const Any = require('./any');
+const Any = require('../any');
 const Hoek = require('hoek');
 
 

package/lib/{number.js → types/number/index.js}

@@ -2,8 +2,8 @@
 
 // Load modules
 
-const Any = require('./any');
-const Ref = require('./ref');
+const Any = require('../any');
+const Ref = require('../../ref');
 const Hoek = require('hoek');
 
 

package/lib/{object.js → types/object/index.js}

@@ -4,10 +4,10 @@
 
 const Hoek = require('hoek');
 const Topo = require('topo');
-const Any = require('./any');
-const Errors = require('./errors');
-const Cast = require('./cast');
-const Ref = require('./ref');
+const Any = require('../any');
+const Errors = require('../../errors');
+const Cast = require('../../cast');
+const Ref = require('../../ref');
 
 
 // Declare internals
@@ -504,6 +504,12 @@ internals.Object = class extends Any {
         return this.applyFunctionToChildren(children, 'optional');
     }
 
+    forbiddenKeys(children) {
+
+        children = Hoek.flatten(Array.prototype.slice.call(arguments));
+        return this.applyFunctionToChildren(children, 'forbidden');
+    }
+
     rename(from, to, options) {
 
         Hoek.assert(typeof from === 'string', 'Rename missing the from argument');

package/lib/{string.js → types/string/index.js}

@@ -4,18 +4,28 @@
 
 const Net = require('net');
 const Hoek = require('hoek');
-const Isemail = require('isemail');
-const Any = require('./any');
-const Ref = require('./ref');
-const JoiDate = require('./date');
-const Uri = require('./string/uri');
-const Ip = require('./string/ip');
+let Isemail;                            // Loaded on demand
+const Any = require('../any');
+const Ref = require('../../ref');
+const JoiDate = require('../date');
+const Uri = require('./uri');
+const Ip = require('./ip');
 
 // Declare internals
 
 const internals = {
     uriRegex: Uri.createUriRegex(),
-    ipRegex: Ip.createIpRegex(['ipv4', 'ipv6', 'ipvfuture'], 'optional')
+    ipRegex: Ip.createIpRegex(['ipv4', 'ipv6', 'ipvfuture'], 'optional'),
+    guidBrackets: {
+        '{': '}', '[': ']', '(': ')', '': ''
+    },
+    guidVersions: {
+        uuidv1: '1',
+        uuidv2: '2',
+        uuidv3: '3',
+        uuidv4: '4',
+        uuidv5: '5'
+    }
 };
 
 internals.String = class extends Any {
@@ -169,6 +179,8 @@ internals.String = class extends Any {
 
         return this._test('email', isEmailOptions, function (value, state, options) {
 
+            Isemail = Isemail || require('isemail');
+
             try {
                 const result = Isemail.validate(value, isEmailOptions);
                 if (result === true || result === 0) {
@@ -324,19 +336,7 @@ internals.String = class extends Any {
 
     guid(guidOptions) {
 
-        const brackets = {
-            '{': '}', '[': ']', '(': ')', '': ''
-        };
-
-        const uuids = {
-            'uuidv1': '1',
-            'uuidv2': '2',
-            'uuidv3': '3',
-            'uuidv4': '4',
-            'uuidv5': '5'
-        };
-
-        const versions = [];
+        let versionNumbers = '';
 
         if (guidOptions && guidOptions.version) {
             if (!Array.isArray(guidOptions.version)) {
@@ -344,50 +344,36 @@ internals.String = class extends Any {
             }
 
             Hoek.assert(guidOptions.version.length >= 1, 'version must have at least 1 valid version specified');
+            const versions = new Set();
 
             for (let i = 0; i < guidOptions.version.length; ++i) {
                 let version = guidOptions.version[i];
                 Hoek.assert(typeof version === 'string', 'version at position ' + i + ' must be a string');
                 version = version.toLowerCase();
-                Hoek.assert(uuids[version], 'version at position ' + i + ' must be one of ' + Object.keys(uuids).join(', '));
-                Hoek.assert(versions.indexOf(version) === -1, 'version at position ' + i + ' must not be a duplicate.');
-                versions.push(version);
+                const versionNumber = internals.guidVersions[version];
+                Hoek.assert(versionNumber, 'version at position ' + i + ' must be one of ' + Object.keys(internals.guidVersions).join(', '));
+                Hoek.assert(!(versions.has(versionNumber)), 'version at position ' + i + ' must not be a duplicate.');
+
+                versionNumbers += versionNumber;
+                versions.add(versionNumber);
             }
         }
 
-        const regex = /^([\[{\(]?)([0-9A-F]{8})([:-]?)([0-9A-F]{4})([:-]?)([0-9A-F]{4})([:-]?)([0-9A-F]{4})([:-]?)([0-9A-F]{12})([\]}\)]?)$/i;
+        const guidRegex = new RegExp(`^([\\[{\\(]?)[0-9A-F]{8}([:-]?)[0-9A-F]{4}\\2?[${versionNumbers || '0-9A-F'}][0-9A-F]{3}\\2?[${versionNumbers ? '89AB' : '0-9A-F'}][0-9A-F]{3}\\2?[0-9A-F]{12}([\\]}\\)]?)$`, 'i');
 
         return this._test('guid', guidOptions, function (value, state, options) {
 
-            const results = regex.exec(value);
+            const results = guidRegex.exec(value);
 
             if (!results) {
                 return this.createError('string.guid', { value }, state, options);
             }
 
             // Matching braces
-            if (brackets[results[1]] !== results[11]) {
+            if (internals.guidBrackets[results[1]] !== results[results.length - 1]) {
                 return this.createError('string.guid', { value }, state, options);
             }
 
-            // Matching separators
-            if (results[3] !== results[5] || results[3] !== results[7] || results[3] !== results[9]) {
-                return this.createError('string.guid', { value }, state, options);
-            }
-
-            // Specific UUID versions
-            if (versions.length) {
-                const validVersions = versions.some((uuidVersion) => {
-
-                    return results[6][0] === uuids[uuidVersion];
-                });
-
-                // Valid version and 89AB check
-                if (!(validVersions && /[89AB]/i.test(results[8][0]))) {
-                    return this.createError('string.guid', { value }, state, options);
-                }
-            }
-
             return value;
         });
     }
@@ -406,9 +392,26 @@ internals.String = class extends Any {
         });
     }
 
-    base64() {
+    base64(base64Options) {
+
+        base64Options = base64Options || {};
+
+        // Validation.
+        Hoek.assert(typeof base64Options === 'object', 'base64 options must be an object');
+        Hoek.assert(typeof base64Options.paddingRequired === 'undefined' || typeof base64Options.paddingRequired === 'boolean',
+            'paddingRequired must be boolean');
+
+        // Determine if padding is required.
+        const paddingRequired = base64Options.paddingRequired === false ?
+            base64Options.paddingRequired
+            : base64Options.paddingRequired || true;
 
-        const regex = /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/;
+        // Set validation based on preference.
+        const regex = paddingRequired ?
+            // Padding is required.
+            /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/
+            // Padding is optional.
+            : /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}(==)?|[A-Za-z0-9+\/]{3}=?)?$/;
 
         return this._test('base64', regex, function (value, state, options) {
 

package/package.json

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