joi 13.1.0 → 13.3.0

package/LICENSE

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

package/README.md

@@ -3,20 +3,10 @@
 Object schema description language and validator for JavaScript objects.
 
 [![npm version](https://badge.fury.io/js/joi.svg)](http://badge.fury.io/js/joi)
-[![Build Status](https://secure.travis-ci.org/hapijs/joi.svg?branch=master)](http://travis-ci.org/hapijs/joi)
-<!--
-
-Remove those badges until they work properly on semver.
-
-[![Dependencies Status](https://david-dm.org/hapijs/joi.svg)](https://david-dm.org/hapijs/joi)
-[![DevDependencies Status](https://david-dm.org/hapijs/joi/dev-status.svg)](https://david-dm.org/hapijs/joi#info=devDependencies)
-
--->
+[![Build Status](https://travis-ci.org/hapijs/joi.svg?branch=master)](https://travis-ci.org/hapijs/joi)
 [![NSP Status](https://nodesecurity.io/orgs/hapijs/projects/0394bf83-b5bc-410b-878c-e8cf1b92033e/badge)](https://nodesecurity.io/orgs/hapijs/projects/0394bf83-b5bc-410b-878c-e8cf1b92033e)
 [![Known Vulnerabilities](https://snyk.io/test/github/hapijs/joi/badge.svg)](https://snyk.io/test/github/hapijs/joi)
 
-[![Join the chat at https://gitter.im/hapijs/joi](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/hapijs/joi?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
 Lead Maintainer: [Nicolas Morel](https://github.com/marsup)
 
 # Introduction
@@ -26,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.1.0/API.md).
+See the detailed [API Reference](https://github.com/hapijs/joi/blob/v13.3.0/API.md).
 
 # Example
 
@@ -129,3 +119,9 @@ When validating a schema:
 # Browsers
 
 Joi doesn't directly support browsers, but you could use [joi-browser](https://github.com/jeffbski/joi-browser) for an ES5 build of Joi that works in browsers, or as a source of inspiration for your own builds.
+
+## Acknowledgements
+
+This project is kindly sponsored by:
+
+[![nearForm logo](https://www.nearform.com/img/nearform-logotype.svg)](https://nearform.com)

package/lib/index.js

@@ -8,6 +8,7 @@ const Cast = require('./cast');
 const Errors = require('./errors');
 const Lazy = require('./types/lazy');
 const Ref = require('./ref');
+const Settings = require('./types/any/settings');
 
 
 // Declare internals
@@ -191,25 +192,31 @@ internals.root = function () {
     root.reach = function (schema, path) {
 
         Hoek.assert(schema && schema instanceof Any, 'you must provide a joi schema');
-        Hoek.assert(typeof path === 'string', 'path must be a string');
+        Hoek.assert(Array.isArray(path) || typeof path === 'string', 'path must be a string or an array of strings');
 
-        if (path === '') {
-            return schema;
-        }
+        const reach = (sourceSchema, schemaPath) => {
 
-        const parts = path.split('.');
-        const children = schema._inner.children;
-        if (!children) {
-            return;
-        }
+            if (!schemaPath.length) {
+                return sourceSchema;
+            }
 
-        const key = parts[0];
-        for (let i = 0; i < children.length; ++i) {
-            const child = children[i];
-            if (child.key === key) {
-                return this.reach(child.schema, path.substr(key.length + 1));
+            const children = sourceSchema._inner.children;
+            if (!children) {
+                return;
             }
-        }
+
+            const key = schemaPath.shift();
+            for (let i = 0; i < children.length; ++i) {
+                const child = children[i];
+                if (child.key === key) {
+                    return reach(child.schema, schemaPath);
+                }
+            }
+        };
+
+        const schemaPath = typeof path === 'string' ? path.split('.') : path.slice();
+
+        return reach(schema, schemaPath);
     };
 
     root.lazy = function (fn) {
@@ -276,9 +283,10 @@ internals.root = function () {
                     this._type = extension.name;
 
                     if (extension.language) {
-                        this._settings = this._settings || { language: {} };
-                        this._settings.language = Hoek.applyToDefaults(this._settings.language, {
-                            [extension.name]: extension.language
+                        this._settings = Settings.concat(this._settings, {
+                            language: {
+                                [extension.name]: extension.language
+                            }
                         });
                     }
                 }

package/lib/language.js

@@ -118,7 +118,8 @@ exports.errors = {
         positive: 'must be a positive number',
         precision: 'must have no more than {{limit}} decimal places',
         ref: 'references "{{ref}}" which is not a number',
-        multiple: 'must be a multiple of {{multiple}}'
+        multiple: 'must be a multiple of {{multiple}}',
+        port: 'must be a valid port'
     },
     string: {
         base: 'must be a string',
@@ -142,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

@@ -3,6 +3,7 @@
 // Load modules
 
 const Hoek = require('hoek');
+const Settings = require('./settings');
 const Ref = require('../../ref');
 const Errors = require('../../errors');
 let Alternatives = null;                // Delay-loaded to prevent circular dependencies
@@ -104,10 +105,10 @@ module.exports = internals.Any = class {
         obj.isJoi = true;
         obj._currentJoi = this._currentJoi;
         obj._type = this._type;
-        obj._settings = internals.concatSettings(this._settings);
+        obj._settings = this._settings;
         obj._baseType = this._baseType;
-        obj._valids = Hoek.clone(this._valids);
-        obj._invalids = Hoek.clone(this._invalids);
+        obj._valids = this._valids.slice();
+        obj._invalids = this._invalids.slice();
         obj._tests = this._tests.slice();
         obj._refs = this._refs.slice();
         obj._flags = Hoek.clone(this._flags);
@@ -150,7 +151,7 @@ module.exports = internals.Any = class {
             obj = tmpObj;
         }
 
-        obj._settings = obj._settings ? internals.concatSettings(obj._settings, schema._settings) : schema._settings;
+        obj._settings = obj._settings ? Settings.concat(obj._settings, schema._settings) : schema._settings;
         obj._valids.merge(schema._valids, schema._invalids);
         obj._invalids.merge(schema._invalids, schema._valids);
         obj._tests = obj._tests.concat(schema._tests);
@@ -218,15 +219,16 @@ module.exports = internals.Any = class {
         this.checkOptions(options);
 
         const obj = this.clone();
-        obj._settings = internals.concatSettings(obj._settings, options);
+        obj._settings = Settings.concat(obj._settings, options);
         return obj;
     }
 
     strict(isStrict) {
 
         const obj = this.clone();
-        obj._settings = obj._settings || {};
-        obj._settings.convert = isStrict === undefined ? false : !isStrict;
+
+        const convert = isStrict === undefined ? false : !isStrict;
+        obj._settings = Settings.concat(obj._settings, { convert });
         return obj;
     }
 
@@ -480,7 +482,7 @@ module.exports = internals.Any = class {
         state = state || { key: '', path: [], parent: null, reference };
 
         if (this._settings) {
-            options = internals.concatSettings(options, this._settings);
+            options = Settings.concat(options, this._settings);
         }
 
         let errors = [];
@@ -593,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
 
@@ -621,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();
                     }
@@ -632,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];
@@ -663,7 +665,7 @@ module.exports = internals.Any = class {
             this.checkOptions(options);
         }
 
-        const settings = internals.concatSettings(internals.defaults, options);
+        const settings = Settings.concat(internals.defaults, options);
         const result = this._validate(value, null, settings);
         const errors = Errors.process(result.errors, value);
 
@@ -880,33 +882,3 @@ internals._try = function (fn, args) {
         error: err
     };
 };
-
-internals.concatSettings = function (target, source) {
-
-    // Used to avoid cloning context
-
-    if (!target &&
-        !source) {
-
-        return null;
-    }
-
-    const obj = Object.assign({}, target);
-
-    if (source) {
-        const sKeys = Object.keys(source);
-        for (let i = 0; i < sKeys.length; ++i) {
-            const key = sKeys[i];
-            if (key !== 'language' ||
-                !obj.hasOwnProperty(key)) {
-
-                obj[key] = source[key];
-            }
-            else {
-                obj[key] = Hoek.applyToDefaults(obj[key], source[key]);
-            }
-        }
-    }
-
-    return obj;
-};

package/lib/types/any/settings.js

@@ -0,0 +1,35 @@
+'use strict';
+
+// Load modules
+
+const Hoek = require('hoek');
+
+
+// Declare internals
+
+const internals = {};
+
+
+exports.concat = function (target, source) {
+
+    if (!source) {
+        return target;
+    }
+
+    const obj = Object.assign({}, target);
+
+    const sKeys = Object.keys(source);
+    for (let i = 0; i < sKeys.length; ++i) {
+        const key = sKeys[i];
+        if (key !== 'language' ||
+            !obj.hasOwnProperty(key)) {
+
+            obj[key] = source[key];
+        }
+        else {
+            obj[key] = Hoek.applyToDefaults(obj[key], source[key]);
+        }
+    }
+
+    return obj;
+};

package/lib/types/array/index.js

@@ -123,6 +123,8 @@ internals.Array = class extends Any {
                     return errors;
                 }
 
+                ordereds.shift();
+
                 continue;
             }
 
@@ -139,6 +141,8 @@ internals.Array = class extends Any {
                         return errors;
                     }
 
+                    ordereds.shift();
+
                     break;
                 }
             }
@@ -491,10 +495,10 @@ internals.Array = class extends Any {
         return this._test('unique', settings, function (value, state, options) {
 
             const found = {
-                string: {},
-                number: {},
-                undefined: {},
-                boolean: {},
+                string: Object.create(null),
+                number: Object.create(null),
+                undefined: Object.create(null),
+                boolean: Object.create(null),
                 object: new Map(),
                 function: new Map(),
                 custom: new Map()

package/lib/types/binary/index.js

@@ -29,7 +29,7 @@ internals.Binary = class extends Any {
             options.convert) {
 
             try {
-                result.value = new Buffer(value, this._flags.encoding);
+                result.value = Buffer.from(value, this._flags.encoding);
             }
             catch (e) {
             }

package/lib/types/number/index.js

@@ -128,6 +128,18 @@ internals.Number = class extends Any {
         return obj;
     }
 
+    port() {
+
+        return this._test('port', undefined, function (value, state, options) {
+
+            if (!Number.isSafeInteger(value) || value < 0 || value > 65535) {
+                return this.createError('number.port', { value }, state, options);
+            }
+
+            return value;
+        });
+    }
+
 };
 
 

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, {}));
                 }
             }
         }
@@ -366,6 +367,15 @@ internals.Object = class extends Any {
         return obj;
     }
 
+    append(schema) {
+        // Skip any changes
+        if (schema === null || schema === undefined || Object.keys(schema).length === 0) {
+            return this;
+        }
+
+        return this.keys(schema);
+    }
+
     unknown(allow) {
 
         const value = allow !== false;
@@ -459,11 +469,15 @@ internals.Object = class extends Any {
 
     with(key, peers) {
 
+        Hoek.assert(arguments.length === 2, 'Invalid number of arguments, expected 2.');
+
         return this._dependency('with', key, peers);
     }
 
     without(key, peers) {
 
+        Hoek.assert(arguments.length === 2, 'Invalid number of arguments, expected 2.');
+
         return this._dependency('without', key, peers);
     }
 

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.1.0",
+  "version": "13.3.0",
   "homepage": "https://github.com/hapijs/joi",
   "repository": "git://github.com/hapijs/joi",
   "main": "lib/index.js",