joi 13.2.0 → 13.3.0

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/v13.2.0/API.md).
+See the detailed [API Reference](https://github.com/hapijs/joi/blob/v13.3.0/API.md).
 
 # Example
 

package/lib/language.js

@@ -143,6 +143,7 @@ exports.errors = {
         isoDate: 'must be a valid ISO 8601 date',
         guid: 'must be a valid GUID',
         hex: 'must only contain hexadecimal characters',
+        hexAlign: 'hex decoded representation must be byte aligned',
         base64: 'must be a valid base64 string',
         hostname: 'must be a valid hostname',
         normalize: 'must be unicode normalized in the {{form}} form',

package/lib/set.js

@@ -2,36 +2,75 @@
 
 const Ref = require('./ref');
 
-module.exports = class Set {
 
-    constructor() {
+const internals = {};
 
-        this._set = [];
+
+internals.extendedCheckForValue = function (value, insensitive) {
+
+    const valueType = typeof value;
+
+    if (valueType === 'object') {
+        if (value instanceof Date) {
+            return (item) => {
+
+                return item instanceof Date && value.getTime() === item.getTime();
+            };
+        }
+        if (Buffer.isBuffer(value)) {
+            return (item) => {
+
+                return Buffer.isBuffer(item) && value.length === item.length && value.toString('binary') === item.toString('binary');
+            };
+        }
+    }
+    else if (insensitive && valueType === 'string') {
+        const lowercaseValue = value.toLowerCase();
+        return (item) => {
+
+            return typeof item === 'string' && lowercaseValue === item.toLowerCase();
+        };
+    }
+
+    return null;
+};
+
+
+module.exports = class InternalSet {
+
+    constructor(from) {
+
+        this._set = new Set(from);
+        this._hasRef = false;
     }
 
     add(value, refs) {
 
-        if (!Ref.isRef(value) && this.has(value, null, null, false)) {
+        const isRef = Ref.isRef(value);
+        if (!isRef && this.has(value, null, null, false)) {
 
-            return;
+            return this;
         }
 
         if (refs !== undefined) { // If it's a merge, we don't have any refs
             Ref.push(refs, value);
         }
 
-        this._set.push(value);
+        this._set.add(value);
+
+        this._hasRef |= isRef;
+
         return this;
     }
 
     merge(add, remove) {
 
-        for (let i = 0; i < add._set.length; ++i) {
-            this.add(add._set[i]);
+        for (const item of add._set) {
+            this.add(item);
         }
 
-        for (let i = 0; i < remove._set.length; ++i) {
-            this.remove(remove._set[i]);
+        for (const item of remove._set) {
+            this.remove(item);
         }
 
         return this;
@@ -39,37 +78,68 @@ module.exports = class Set {
 
     remove(value) {
 
-        this._set = this._set.filter((item) => value !== item);
+        this._set.delete(value);
         return this;
     }
 
     has(value, state, options, insensitive) {
 
-        for (let i = 0; i < this._set.length; ++i) {
-            let items = this._set[i];
+        if (!this._set.size) {
+            return false;
+        }
+
+        const hasValue = this._set.has(value);
+        if (hasValue) {
+            return hasValue;
+        }
 
-            if (state && Ref.isRef(items)) { // Only resolve references if there is a state, otherwise it's a merge
-                items = items(state.reference || state.parent, options);
+        const extendedCheck = internals.extendedCheckForValue(value, insensitive);
+        if (!extendedCheck) {
+            if (state && this._hasRef) {
+                for (let item of this._set) {
+                    if (Ref.isRef(item)) {
+                        item = item(state.reference || state.parent, options);
+                        if (value === item || (Array.isArray(item) && item.includes(value))) {
+                            return true;
+                        }
+                    }
+                }
             }
 
-            if (!Array.isArray(items)) {
-                items = [items];
+            return false;
+        }
+
+        return this._has(value, state, options, extendedCheck);
+    }
+
+    _has(value, state, options, check) {
+
+        const checkRef = !!(state && this._hasRef);
+
+        const isReallyEqual = function (item) {
+
+            if (value === item) {
+                return true;
             }
 
-            for (let j = 0; j < items.length; ++j) {
-                const item = items[j];
-                if (typeof value !== typeof item) {
-                    continue;
-                }
+            return check(item);
+        };
 
-                if (value === item ||
-                    (value instanceof Date && item instanceof Date && value.getTime() === item.getTime()) ||
-                    (insensitive && typeof value === 'string' && value.toLowerCase() === item.toLowerCase()) ||
-                    (Buffer.isBuffer(value) && Buffer.isBuffer(item) && value.length === item.length && value.toString('binary') === item.toString('binary'))) {
+        for (let item of this._set) {
+            if (checkRef && Ref.isRef(item)) { // Only resolve references if there is a state, otherwise it's a merge
+                item = item(state.reference || state.parent, options);
 
-                    return true;
+                if (Array.isArray(item)) {
+                    if (item.find(isReallyEqual)) {
+                        return true;
+                    }
+                    continue;
                 }
             }
+
+            if (isReallyEqual(item)) {
+                return true;
+            }
         }
 
         return false;
@@ -80,8 +150,7 @@ module.exports = class Set {
         if (options && options.stripUndefined) {
             const values = [];
 
-            for (let i = 0; i < this._set.length; ++i) {
-                const item = this._set[i];
+            for (const item of this._set) {
                 if (item !== undefined) {
                     values.push(item);
                 }
@@ -90,22 +159,20 @@ module.exports = class Set {
             return values;
         }
 
-        return this._set.slice();
+        return Array.from(this._set);
     }
 
     slice() {
 
-        const newSet = new Set();
-        newSet._set = this._set.slice();
-
-        return newSet;
+        const set = new InternalSet(this._set);
+        set._hasRef = this._hasRef;
+        return set;
     }
 
     concat(source) {
 
-        const newSet = new Set();
-        newSet._set = this._set.concat(source._set);
-
-        return newSet;
+        const set = new InternalSet([...this._set, ...source._set]);
+        set._hasRef = !!(this._hasRef | source._hasRef);
+        return set;
     }
 };

package/lib/types/any/index.js

@@ -595,7 +595,7 @@ module.exports = internals.Any = class {
         }
 
         if (this._invalids.has(value, state, options, this._flags.insensitive)) {
-            errors.push(this.createError(value === '' ? 'any.empty' : 'any.invalid', null, state, options));
+            errors.push(this.createError(value === '' ? 'any.empty' : 'any.invalid', { value, invalids: this._invalids.values({ stripUndefined: true }) }, state, options));
             if (options.abortEarly ||
                 value === undefined) {          // No reason to keep validating missing value
 
@@ -623,7 +623,7 @@ module.exports = internals.Any = class {
                 }
 
                 if (this._invalids.has(value, state, options, this._flags.insensitive)) {
-                    errors.push(this.createError(value === '' ? 'any.empty' : 'any.invalid', null, state, options));
+                    errors.push(this.createError(value === '' ? 'any.empty' : 'any.invalid', { value, invalids: this._invalids.values({ stripUndefined: true }) }, state, options));
                     if (options.abortEarly) {
                         return finish();
                     }
@@ -634,13 +634,13 @@ module.exports = internals.Any = class {
         // Required values did not match
 
         if (this._flags.allowOnly) {
-            errors.push(this.createError('any.allowOnly', { valids: this._valids.values({ stripUndefined: true }) }, state, options));
+            errors.push(this.createError('any.allowOnly', { value, valids: this._valids.values({ stripUndefined: true }) }, state, options));
             if (options.abortEarly) {
                 return finish();
             }
         }
 
-        // Helper.validate tests
+        // Validate tests
 
         for (let i = 0; i < this._tests.length; ++i) {
             const test = this._tests[i];

package/lib/types/object/index.js

@@ -191,7 +191,7 @@ internals.Object = class extends Any {
             return finish();
         }
 
-        const unprocessed = Hoek.mapToObject(Object.keys(target));
+        const unprocessed = new Set(Object.keys(target));
 
         if (this._inner.children) {
             const stripProps = [];
@@ -201,7 +201,7 @@ internals.Object = class extends Any {
                 const key = child.key;
                 const item = target[key];
 
-                delete unprocessed[key];
+                unprocessed.delete(key);
 
                 const localState = { key, path: state.path.concat(key), parent: target, reference: state.reference };
                 const result = child.schema._validate(item, localState, options);
@@ -230,24 +230,30 @@ internals.Object = class extends Any {
 
         // Unknown keys
 
-        let unprocessedKeys = Object.keys(unprocessed);
-        if (unprocessedKeys.length &&
-            this._inner.patterns.length) {
+        if (unprocessed.size && this._inner.patterns.length) {
 
-            for (let i = 0; i < unprocessedKeys.length; ++i) {
-                const key = unprocessedKeys[i];
-                const localState = { key, path: state.path.concat(key), parent: target, reference: state.reference };
+            for (const key of unprocessed) {
+                const localState = {
+                    key,
+                    path: state.path.concat(key),
+                    parent: target,
+                    reference: state.reference
+                };
                 const item = target[key];
 
-                for (let j = 0; j < this._inner.patterns.length; ++j) {
-                    const pattern = this._inner.patterns[j];
+                for (let i = 0; i < this._inner.patterns.length; ++i) {
+                    const pattern = this._inner.patterns[i];
 
                     if (pattern.regex.test(key)) {
-                        delete unprocessed[key];
+                        unprocessed.delete(key);
 
                         const result = pattern.rule._validate(item, localState, options);
                         if (result.errors) {
-                            errors.push(this.createError('object.child', { key, child: pattern.rule._getLabel(key), reason: result.errors }, localState, options));
+                            errors.push(this.createError('object.child', {
+                                key,
+                                child: pattern.rule._getLabel(key),
+                                reason: result.errors
+                            }, localState, options));
 
                             if (options.abortEarly) {
                                 return finish();
@@ -258,11 +264,9 @@ internals.Object = class extends Any {
                     }
                 }
             }
-
-            unprocessedKeys = Object.keys(unprocessed);
         }
 
-        if ((this._inner.children || this._inner.patterns.length) && unprocessedKeys.length) {
+        if (unprocessed.size && (this._inner.children || this._inner.patterns.length)) {
             if ((options.stripUnknown && this._flags.allowUnknown !== true) ||
                 options.skipFunctions) {
 
@@ -271,27 +275,24 @@ internals.Object = class extends Any {
                     : false;
 
 
-                for (let i = 0; i < unprocessedKeys.length; ++i) {
-                    const key = unprocessedKeys[i];
-
+                for (const key of unprocessed) {
                     if (stripUnknown) {
                         delete target[key];
-                        delete unprocessed[key];
+                        unprocessed.delete(key);
                     }
                     else if (typeof target[key] === 'function') {
-                        delete unprocessed[key];
+                        unprocessed.delete(key);
                     }
                 }
-
-                unprocessedKeys = Object.keys(unprocessed);
             }
 
-            if (unprocessedKeys.length &&
-                (this._flags.allowUnknown !== undefined ? !this._flags.allowUnknown : !options.allowUnknown)) {
+            if ((this._flags.allowUnknown !== undefined ? !this._flags.allowUnknown : !options.allowUnknown)) {
 
-                for (let i = 0; i < unprocessedKeys.length; ++i) {
-                    const unprocessedKey = unprocessedKeys[i];
-                    errors.push(this.createError('object.allowUnknown', { child: unprocessedKey }, { key: unprocessedKey, path: state.path.concat(unprocessedKey) }, options, {}));
+                for (const unprocessedKey of unprocessed) {
+                    errors.push(this.createError('object.allowUnknown', { child: unprocessedKey }, {
+                        key: unprocessedKey,
+                        path: state.path.concat(unprocessedKey)
+                    }, options, {}));
                 }
             }
         }

package/lib/types/string/index.js

@@ -73,6 +73,10 @@ internals.String = class extends Any {
                     }
                 }
             }
+
+            if (this._flags.byteAligned && value.length % 2 !== 0) {
+                value = `0${value}`;
+            }
         }
 
         return {
@@ -399,18 +403,32 @@ internals.String = class extends Any {
         });
     }
 
-    hex() {
+    hex(hexOptions = {}) {
 
+        Hoek.assert(typeof hexOptions === 'object', 'hex options must be an object');
+        Hoek.assert(typeof hexOptions.byteAligned === 'undefined' || typeof hexOptions.byteAligned === 'boolean',
+            'byteAligned must be boolean');
+
+        const byteAligned = hexOptions.byteAligned === true;
         const regex = /^[a-f0-9]+$/i;
 
-        return this._test('hex', regex, function (value, state, options) {
+        const obj = this._test('hex', regex, function (value, state, options) {
 
             if (regex.test(value)) {
+                if (byteAligned && value.length % 2 !== 0) {
+                    return this.createError('string.hexAlign', { value }, state, options);
+                }
                 return value;
             }
 
             return this.createError('string.hex', { value }, state, options);
         });
+
+        if (byteAligned) {
+            obj._flags.byteAligned = true;
+        }
+
+        return obj;
     }
 
     base64(base64Options = {}) {

package/package.json

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