joi 8.4.2 → 9.0.0-0

package/README.md

@@ -95,4 +95,4 @@ 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/v8.4.2/API.md).
+See the [API Reference](https://github.com/hapijs/joi/blob/v9.0.0-0/API.md).

package/examples/conditionalRequire.js

@@ -0,0 +1,52 @@
+'use strict';
+
+// Load modules
+
+const Joi = require('../');
+
+// Delcare internals
+
+const internals = {};
+
+
+// This is an example of a survey to obtain the reputation of Parisians
+// It contains examples of how to conditionally require keys based on values of other keys
+
+// This is a valid value for integer rating 1 - 5
+const intRating = Joi.number().integer().min(1).max(5);
+
+const schema = Joi.object().keys({
+    // Do you know any French people? yes or no (required)
+    q1: Joi.boolean().required(),
+    // Do you know any Parisians? yes or no (required if answered yes in q1)
+    q2: Joi.boolean()
+        .when('q1', { is: true, then: Joi.required() }),
+    // How many french in paris do you know? 1-6, 6-10, 11-50 or 50+ (required if answered yes in q2)
+    q3: Joi.string()
+        .when('q2', { is: true, then: Joi.valid('1-5', '6-10', '11-50', '50+').required() }),
+    // Rate 20% of most friendly Parisians, from how many people you know answered in q3, individually on 1-5 rating
+    q4: Joi.array()
+        .when('q3', {is: '1-5', then: Joi.array().min(0).max(1).items(intRating).required() })
+        .when('q3', {is: '6-10', then: Joi.array().min(1).max(2).items(intRating).required() })
+        .when('q3', {is: '11-50', then: Joi.array().min(2).max(10).items(intRating).required() })
+        .when('q3', {is: '50+', then: Joi.array().min(10).items(intRating).required() }),
+    // Rate remaining 80% of Parisians, from how many people you know answered in q3, individually on 1-5 rating
+    q5: Joi.array()
+        .when('q3', {is: '1-5', then: Joi.array().min(1).max(4).items(intRating).required() })
+        .when('q3', {is: '6-10', then: Joi.array().min(4).max(8).items(intRating).required() })
+        .when('q3', {is: '11-50', then: Joi.array().min(8).max(40).items(intRating).required() })
+        .when('q3', {is: '50+', then: Joi.array().min(40).items(intRating).required().required() }),
+    // Rate the reputation of Parisians in general, 1-5 rating
+    q6: intRating.required()
+});
+
+const response = {
+	q1: true,
+	q2: true,
+	q3: '1-5',
+	q4: [5],
+	q5: [1],
+	q6: 2
+};
+
+Joi.assert(response, schema);

package/examples/customMessage.js

@@ -0,0 +1,31 @@
+'use strict';
+
+// Load modules
+
+const Joi = require('../');
+
+
+// Declare internals
+
+const internals = {};
+
+
+const schema = Joi.object().options({ abortEarly: false }).keys({
+    email: Joi.string().email().required().label('User Email'),
+    password: Joi.string().min(8).required(),
+    password_confirmation: Joi.any().valid(Joi.ref('password')).required().options({ language: { any: { allowOnly: 'must match password' }, label: 'Password Confirmation' } }).label('This label is not used because language.label takes precedence'),
+    first_name: Joi.string().required(),
+    last_name: Joi.string().required(),
+    company: Joi.string().optional()
+});
+
+
+const data = {
+    email: 'not_a_valid_email_to_show_custom_label',
+    password: 'abcd1234',
+    password_confirmation: 'abc1',
+    first_name: 'Joe',
+    last_name: 'Doe'
+};
+
+Joi.assert(data, schema);

package/examples/multipleWhen.js

@@ -0,0 +1,26 @@
+'use strict';
+
+// Load modules
+
+const Joi = require('../');
+
+
+// Declare internals
+
+const internals = {};
+
+
+const schema = {
+    type: Joi.string().required(),
+    subtype: Joi.alternatives()
+        .when('type', {is: 'video', then: Joi.valid('mp4', 'wav')})
+        .when('type', {is: 'audio', then: Joi.valid('mp3')})
+        .when('type', {is: 'image', then: Joi.valid('jpg', 'png')})
+        .when('type', {is: 'pdf'  , then: Joi.valid('document')})
+};
+
+
+Joi.assert({ type: 'video', subtype: 'mp4' }, schema); // Pass
+Joi.assert({ type: 'video', subtype: 'wav' }, schema); // Pass
+Joi.assert({ type: 'other', subtype: 'something' }, schema); // Fail
+Joi.assert({ type: 'audio', subtype: 'mp4' }, schema); // Fail

package/examples/timestamps.js

@@ -0,0 +1,22 @@
+'use strict';
+
+// Load modules
+const Joi = require('../');
+
+const now = new Date();
+const javascriptTimestamp = now.getTime();
+const unixTimestamp = now.getTime() / 1000;
+
+const schema = Joi.object().options({ abortEarly: false }).keys({
+  javascript1: Joi.date().timestamp(),
+  javascript2: Joi.date().timestamp('javascript'),
+  unix: Joi.date().timestamp('unix')
+});
+
+const data = {
+  javascript1: javascriptTimestamp,
+  javascript2: javascriptTimestamp,
+  unix: unixTimestamp
+};
+
+Joi.assert(data, schema);

package/generate-readme-toc.js

@@ -0,0 +1,49 @@
+'use strict';
+
+// Load modules
+
+const Toc = require('markdown-toc');
+const Fs = require('fs');
+const Package = require('./package.json');
+
+// Declare internals
+
+const internals = {
+    api: {
+        filename: './API.md',
+        contents: Fs.readFileSync('./API.md', 'utf8')
+    },
+    readme: {
+        filename: './README.md',
+        contents: Fs.readFileSync('./README.md', 'utf8')
+    }
+};
+
+internals.generateToc = function () {
+
+    const tocOptions = {
+        bullets: '-',
+        slugify: function (text) {
+
+            return text.toLowerCase()
+                .replace(/\s/g, '-')
+                .replace(/[^\w-]/g, '');
+        }
+    };
+
+    const api = Toc.insert(internals.api.contents, tocOptions)
+        .replace(/<!-- version -->(.|\n)*<!-- versionstop -->/, `<!-- version -->\n# ${Package.version} API Reference\n<!-- versionstop -->`);
+
+    Fs.writeFileSync(internals.api.filename, api);
+};
+
+internals.generateLink = function () {
+    // create absolute URL for versioned docs
+    const readme = internals.readme.contents
+        .replace(/\[API Reference\]\(.*\)/gi, `[API Reference](${Package.homepage || ''}/blob/v${Package.version}/${internals.api.filename.substr(2)})`);
+
+    Fs.writeFileSync(internals.readme.filename, readme);
+};
+
+internals.generateToc();
+internals.generateLink();

package/lib/any.js

@@ -32,10 +32,37 @@ internals.defaults = {
 
 internals.checkOptions = function (options) {
 
-    const Schemas = require('./schemas');
-    const result = Schemas.options.validate(options);
-    if (result.error) {
-        throw new Error(result.error.details[0].message);
+    const optionType = {
+        abortEarly: 'boolean',
+        convert: 'boolean',
+        allowUnknown: 'boolean',
+        skipFunctions: 'boolean',
+        stripUnknown: 'boolean',
+        language: 'object',
+        presence: ['string', 'required', 'optional', 'forbidden', 'ignore'],
+        raw: 'boolean',
+        context: 'object',
+        strip: 'boolean',
+        noDefaults: 'boolean'
+    };
+
+    const keys = Object.keys(options);
+    for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        const opt = optionType[key];
+        let type = opt;
+        let values = null;
+
+        if (Array.isArray(opt)) {
+            type = opt[0];
+            values = opt.slice(1);
+        }
+
+        Hoek.assert(type, 'unknown key ' + key);
+        Hoek.assert(typeof options[key] === type, key + ' should be of type ' + type);
+        if (values) {
+            Hoek.assert(values.indexOf(options[key]) >= 0, key + ' should be one of ' + values.join(', '));
+        }
     }
 };
 
@@ -51,8 +78,7 @@ module.exports = internals.Any = function () {
     this._invalids = new internals.Set();
     this._tests = [];
     this._refs = [];
-    this._flags = {
-    /*
+    this._flags = { /*
         presence: 'optional',                   // optional, required, forbidden, ignore
         allowOnly: false,
         allowUnknown: undefined,
@@ -64,8 +90,7 @@ module.exports = internals.Any = function () {
         case: undefined,                        // upper, lower
         empty: undefined,
         func: false
-    */
-    };
+    */ };
 
     this._description = null;
     this._unit = null;
@@ -192,10 +217,10 @@ internals.Any.prototype.concat = function (schema) {
 };
 
 
-internals.Any.prototype._test = function (name, arg, func) {
+internals.Any.prototype._test = function (name, arg, func, options) {
 
     const obj = this.clone();
-    obj._tests.push({ func, name, arg });
+    obj._tests.push({ func, name, arg, options });
     return obj;
 };
 
@@ -229,17 +254,6 @@ internals.Any.prototype.raw = function (isRaw) {
 };
 
 
-internals.Any.prototype.error = function (err) {
-
-    Hoek.assert(err && err instanceof Error, 'Must provide a valid Error object');
-
-    const obj = this.clone();
-    obj._settings = obj._settings || {};
-    obj._settings.error = err;
-    return obj;
-};
-
-
 internals.Any.prototype._allow = function () {
 
     const values = Hoek.flatten(Array.prototype.slice.call(arguments));
@@ -378,7 +392,7 @@ internals.Any.prototype.when = function (ref, options) {
     Alternatives = Alternatives || require('./alternatives');
     const obj = Alternatives.when(ref, { is: options.is, then, otherwise });
     obj._flags.presence = 'ignore';
-    obj._settings = internals.concatSettings(obj._settings, { baseType: this });
+    obj._settings = internals.concatSettings({ baseType: this }, obj._settings);
 
     return obj;
 };
@@ -609,13 +623,16 @@ internals.Any.prototype._validate = function (value, state, options, reference)
 
     for (let i = 0; i < this._tests.length; ++i) {
         const test = this._tests[i];
-        const err = test.func.call(this, value, state, options);
-        if (err) {
-            errors.push(err);
+        const ret = test.func.call(this, value, state, options);
+        if (ret && ret.isJoi) {
+            errors.push(ret);
             if (options.abortEarly) {
                 return finish();
             }
         }
+        else if (ret !== null) {
+            value = ret;
+        }
     }
 
     return finish();
@@ -640,13 +657,16 @@ internals.Any.prototype._validateWithOptions = function (value, options, callbac
 };
 
 
-internals.Any.prototype.validate = function (value, options, callback) {
+internals.Any.prototype.validate = function (value, callback) {
+
+    const result = this._validate(value, null, internals.defaults);
+    const errors = Errors.process(result.errors, value);
 
-    if (typeof options === 'function') {
-        return this._validateWithOptions(value, null, options);
+    if (callback) {
+        return callback(errors, result.value);
     }
 
-    return this._validateWithOptions(value, options, callback);
+    return { error: errors, value: result.value };
 };
 
 
@@ -658,7 +678,7 @@ internals.Any.prototype.describe = function () {
 
     const flags = Object.keys(this._flags);
     if (flags.length) {
-        if (this._flags.hasOwnProperty('empty') || this._flags.hasOwnProperty('default') || this._flags.lazy) {
+        if (this._flags.hasOwnProperty('empty') || this._flags.hasOwnProperty('default')) {
             description.flags = {};
             for (let i = 0; i < flags.length; ++i) {
                 const flag = flags[i];
@@ -676,9 +696,6 @@ internals.Any.prototype.describe = function () {
                         description.flags[flag] = this._flags[flag];
                     }
                 }
-                else if (flag === 'lazy') {
-                    // We don't want it in the description
-                }
                 else {
                     description.flags[flag] = this._flags[flag];
                 }
@@ -734,9 +751,31 @@ internals.Any.prototype.describe = function () {
     for (let i = 0; i < this._tests.length; ++i) {
         const validator = this._tests[i];
         const item = { name: validator.name };
+
         if (validator.arg !== void 0) {
             item.arg = Ref.isRef(validator.arg) ? validator.arg.toString() : validator.arg;
         }
+
+        const options = validator.options;
+        if (options) {
+            if (options.hasRef) {
+                item.arg = {};
+                const keys = Object.keys(validator.arg);
+                for (let j = 0; j < keys.length; ++j) {
+                    const key = keys[j];
+                    const value = validator.arg[key];
+                    item.arg[key] = Ref.isRef(value) ? value.toString() : value;
+                }
+            }
+
+            if (typeof options.description === 'string') {
+                item.description = options.description;
+            }
+            else if (typeof options.description === 'function') {
+                item.description = options.description(item.arg);
+            }
+        }
+
         description.rules.push(item);
     }
 
@@ -752,7 +791,6 @@ internals.Any.prototype.describe = function () {
     return description;
 };
 
-
 internals.Any.prototype.label = function (name) {
 
     Hoek.assert(name && typeof name === 'string', 'Label name must be a non-empty string');
@@ -760,7 +798,8 @@ internals.Any.prototype.label = function (name) {
     const obj = this.clone();
     const options = { language: { label: name } };
 
-    obj._settings = internals.concatSettings(obj._settings, options);
+    // If language.label is set, it should override this label
+    obj._settings = internals.concatSettings(options, obj._settings);
     return obj;
 };
 

package/lib/array.js

@@ -38,17 +38,6 @@ internals.Array = function () {
 Hoek.inherits(internals.Array, Any);
 
 
-internals.safeParse = function (value, result) {
-
-    try {
-        const converted = JSON.parse(value);
-        if (Array.isArray(converted)) {
-            result.value = converted;
-        }
-    }
-    catch (e) { }
-};
-
 internals.Array.prototype._base = function (value, state, options) {
 
     const result = {
@@ -58,7 +47,13 @@ internals.Array.prototype._base = function (value, state, options) {
     if (typeof value === 'string' &&
         options.convert) {
 
-        internals.safeParse(value, result);
+        try {
+            const converted = JSON.parse(value);
+            if (Array.isArray(converted)) {
+                result.value = converted;
+            }
+        }
+        catch (e) { }
     }
 
     let isArray = Array.isArray(result.value);
@@ -75,8 +70,6 @@ internals.Array.prototype._base = function (value, state, options) {
 
     if (this._inner.inclusions.length ||
         this._inner.exclusions.length ||
-        this._inner.requireds.length ||
-        this._inner.ordereds.length ||
         !this._flags.sparse) {
 
         // Clone the array so that we don't modify the original
@@ -129,7 +122,7 @@ internals.checkItems = function (items, wasArray, state, options) {
         // Sparse
 
         if (!this._flags.sparse && item === undefined) {
-            errors.push(this.createError('array.sparse', null, { key: state.key, path: localState.path, pos: i }, options));
+            errors.push(this.createError('array.sparse', null, { key: state.key, path: localState.path }, options));
 
             if (options.abortEarly) {
                 return errors;
@@ -170,15 +163,6 @@ internals.checkItems = function (items, wasArray, state, options) {
                         --i;
                         --il;
                     }
-                    else if (!this._flags.sparse && res.value === undefined) {
-                        errors.push(this.createError('array.sparse', null, { key: state.key, path: localState.path, pos: i }, options));
-
-                        if (options.abortEarly) {
-                            return errors;
-                        }
-
-                        continue;
-                    }
                     else {
                         items[i] = res.value;
                     }
@@ -212,15 +196,6 @@ internals.checkItems = function (items, wasArray, state, options) {
                 internals.fastSplice(requireds, j);
                 --j;
                 --jl;
-
-                if (!this._flags.sparse && res.value === undefined) {
-                    errors.push(this.createError('array.sparse', null, { key: state.key, path: localState.path, pos: i }, options));
-
-                    if (options.abortEarly) {
-                        return errors;
-                    }
-                }
-
                 break;
             }
         }
@@ -231,10 +206,6 @@ internals.checkItems = function (items, wasArray, state, options) {
 
         // Inclusions
 
-        const stripUnknown = options.stripUnknown
-            ? (options.stripUnknown === true ? true : !!options.stripUnknown.arrays)
-            : false;
-
         jl = inclusions.length;
         for (let j = 0; j < jl; ++j) {
             const inclusion = inclusions[j];
@@ -253,10 +224,6 @@ internals.checkItems = function (items, wasArray, state, options) {
                         --i;
                         --il;
                     }
-                    else if (!this._flags.sparse && res.value === undefined) {
-                        errors.push(this.createError('array.sparse', null, { key: state.key, path: localState.path, pos: i }, options));
-                        errored = true;
-                    }
                     else {
                         items[i] = res.value;
                     }
@@ -267,7 +234,7 @@ internals.checkItems = function (items, wasArray, state, options) {
 
             // Return the actual error if only one inclusion defined
             if (jl === 1) {
-                if (stripUnknown) {
+                if (options.stripUnknown) {
                     internals.fastSplice(items, i);
                     --i;
                     --il;
@@ -291,7 +258,7 @@ internals.checkItems = function (items, wasArray, state, options) {
         }
 
         if (this._inner.inclusions.length && !isValid) {
-            if (stripUnknown) {
+            if (options.stripUnknown) {
                 internals.fastSplice(items, i);
                 --i;
                 --il;
@@ -334,7 +301,7 @@ internals.fillMissedErrors = function (errors, requireds, state, options) {
 
     if (knownMisses.length) {
         if (unknownMisses) {
-            errors.push(this.createError('array.includesRequiredBoth', { knownMisses: knownMisses, unknownMisses: unknownMisses }, { key: state.key, path: state.path }, options));
+            errors.push(this.createError('array.includesRequiredBoth', { knownMisses: knownMisses, unknownMisses: unknownMisses }, { key: state.key, path: state.patk }, options));
         }
         else {
             errors.push(this.createError('array.includesRequiredKnowns', { knownMisses: knownMisses }, { key: state.key, path: state.path }, options));

package/lib/boolean.js

@@ -30,8 +30,15 @@ internals.Boolean.prototype._base = function (value, state, options) {
         options.convert) {
 
         const lower = value.toLowerCase();
-        result.value = (lower === 'true' || lower === 'yes' || lower === 'on' ? true
-                                                                              : (lower === 'false' || lower === 'no' || lower === 'off' ? false : value));
+        result.value = (lower === 'true' || lower === 'yes' || lower === 'on' || lower === '1' ? true
+                                                        : (lower === 'false' || lower === 'no' || lower === 'off' || lower === '0' ? false : value));
+    }
+
+    if (typeof value === 'number' &&
+        options.convert) {
+
+        result.value = (value === 1 ? true
+                : (value === 0 ? false : value));
     }
 
     result.errors = (typeof result.value === 'boolean') ? null : this.createError('boolean.base', null, state, options);

package/lib/date.js

@@ -41,9 +41,6 @@ internals.Date.prototype._base = function (value, state, options) {
     if (result.value instanceof Date && !isNaN(result.value.getTime())) {
         result.errors = null;
     }
-    else if (!options.convert) {
-        result.errors = this.createError('date.strict', null, state, options);
-    }
     else {
         let type;
         if (internals.isIsoDate(this._flags.format)) {

package/lib/errors.js

@@ -115,39 +115,28 @@ exports.process = function (errors, object) {
         for (let i = 0; i < localErrors.length; ++i) {
             const item = localErrors[i];
 
-            if (item.options.error) {
-                return item.options.error;
-            }
+            const detail = {
+                message: item.toString(),
+                path: internals.getPath(item),
+                type: item.type,
+                context: item.context
+            };
 
-            let itemMessage;
             if (parent === undefined) {
-                itemMessage = item.toString();
-                message = message + (message ? '. ' : '') + itemMessage;
+                message = message + (message ? '. ' : '') + detail.message;
             }
 
             // Do not push intermediate errors, we're only interested in leafs
-
             if (item.context.reason && item.context.reason.length) {
-                const override = processErrors(item.context.reason, item.path);
-                if (override) {
-                    return override;
-                }
+                processErrors(item.context.reason, item.path);
             }
             else {
-                details.push({
-                    message: itemMessage || item.toString(),
-                    path: internals.getPath(item),
-                    type: item.type,
-                    context: item.context
-                });
+                details.push(detail);
             }
         }
     };
 
-    const override = processErrors(errors);
-    if (override) {
-        return override;
-    }
+    processErrors(errors);
 
     const error = new Error(message);
     error.isJoi = true;
@@ -161,7 +150,17 @@ exports.process = function (errors, object) {
 
 internals.getPath = function (item) {
 
-    return item.path || item.context.key;
+    const recursePath = (it) => {
+
+        const reachedItem = Hoek.reach(it, 'context.reason.0');
+        if (reachedItem && reachedItem.context) {
+            return recursePath(reachedItem);
+        }
+
+        return it.path;
+    };
+
+    return recursePath(item) || item.context.key;
 };