joi 10.5.2 → 10.6.0

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.5.2/API.md).
+See the [API Reference](https://github.com/hapijs/joi/blob/v10.6.0/API.md).
 
 # Browsers
 

package/lib/index.js

@@ -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/types/array/index.js

@@ -4,6 +4,7 @@
 
 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/types/string/index.js

@@ -15,7 +15,17 @@ const Ip = require('./ip');
 
 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 {
@@ -326,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)) {
@@ -346,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]) {
-                return this.createError('string.guid', { value }, state, options);
-            }
-
-            // Matching separators
-            if (results[3] !== results[5] || results[3] !== results[7] || results[3] !== results[9]) {
+            if (internals.guidBrackets[results[1]] !== results[results.length - 1]) {
                 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;
         });
     }
@@ -408,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.5.2",
+  "version": "10.6.0",
   "homepage": "https://github.com/hapijs/joi",
   "repository": "git://github.com/hapijs/joi",
   "main": "lib/index.js",