joi 8.3.0 → 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.3.0/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,26 +32,37 @@ internals.defaults = {
 
 internals.checkOptions = function (options) {
 
-    const Joi = require('../');
+    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;
 
-    const optionsSchema = Joi.object({
-        abortEarly: Joi.boolean(),
-        convert: Joi.boolean(),
-        allowUnknown: Joi.boolean(),
-        skipFunctions: Joi.boolean(),
-        stripUnknown: [Joi.boolean(), Joi.object({ arrays: Joi.boolean(), objects: Joi.boolean() }).or('arrays', 'objects')],
-        language: Joi.object(),
-        presence: Joi.string().only('required', 'optional', 'forbidden', 'ignore'),
-        raw: Joi.boolean(),
-        context: Joi.object(),
-        strip: Joi.boolean(),
-        noDefaults: Joi.boolean(),
-        error: Joi.object()
-    }).strict();
+        if (Array.isArray(opt)) {
+            type = opt[0];
+            values = opt.slice(1);
+        }
 
-    const result = optionsSchema.validate(options);
-    if (result.error) {
-        throw new Error(result.error.details[0].message);
+        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(', '));
+        }
     }
 };
 
@@ -67,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,
@@ -80,8 +90,7 @@ module.exports = internals.Any = function () {
         case: undefined,                        // upper, lower
         empty: undefined,
         func: false
-    */
-    };
+    */ };
 
     this._description = null;
     this._unit = null;
@@ -208,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;
 };
 
@@ -245,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));
@@ -394,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;
 };
@@ -625,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();
@@ -677,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];
@@ -695,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];
                 }
@@ -753,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);
     }
 
@@ -771,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');
@@ -779,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

@@ -206,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];
@@ -238,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;
@@ -262,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;

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/errors.js

@@ -115,10 +115,6 @@ 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),
@@ -131,12 +127,8 @@ exports.process = function (errors, object) {
             }
 
             // 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(detail);
@@ -144,10 +136,7 @@ exports.process = function (errors, object) {
         }
     };
 
-    const override = processErrors(errors);
-    if (override) {
-        return override;
-    }
+    processErrors(errors);
 
     const error = new Error(message);
     error.isJoi = true;

package/lib/index.js

@@ -5,7 +5,6 @@
 const Hoek = require('hoek');
 const Any = require('./any');
 const Cast = require('./cast');
-const Lazy = require('./lazy');
 const Ref = require('./ref');
 
 
@@ -173,13 +172,153 @@ internals.root = function () {
         }
     };
 
-    root.lazy = function (fn) {
+    root.extend = function () {
 
-        return Lazy.set(fn);
+        const extensions = Hoek.flatten(Array.prototype.slice.call(arguments));
+        Hoek.assert(extensions.length > 0, 'You need to provide at least one extension');
+
+        this.assert(extensions, internals.extensionsSchema);
+
+        const joi = Object.assign({}, this);
+
+        for (let i = 0; i < extensions.length; ++i) {
+            const extension = extensions[i];
+            const base = (extension.base || this.any()).clone(); // Cloning because we're going to override language afterwards
+            const ctor = base.constructor;
+            const type = function () { // eslint-disable-line no-loop-func
+
+                ctor.call(this);
+
+                if (extension.base) {
+                    Object.assign(this, base);
+                }
+
+                this._type = extension.name;
+
+                if (extension.language) {
+                    this._settings = this._settings || { language: {} };
+                    this._settings.language = Hoek.applyToDefaults(this._settings.language, {
+                        [extension.name]: extension.language
+                    });
+                }
+            };
+            Hoek.inherits(type, ctor);
+
+            if (extension.pre) {
+                type.prototype._base = function (value, state, options) {
+
+                    if (ctor.prototype._base) {
+                        const baseRet = ctor.prototype._base.call(this, value, state, options);
+
+                        if (baseRet.errors) {
+                            return baseRet;
+                        }
+
+                        value = baseRet.value;
+                    }
+
+                    const ret = extension.pre.call(this, value, state, options);
+                    if (ret && ret.isJoi) {
+                        return { value, errors: ret };
+                    }
+                    else if (ret !== null) {
+                        return { value: ret };
+                    }
+
+                    return { value };
+                };
+            }
+
+            if (extension.rules) {
+                for (let j = 0; j < extension.rules.length; ++j) {
+                    const rule = extension.rules[j];
+                    const ruleArgs = rule.params ?
+                        (rule.params instanceof Any ? rule.params._inner.children.map((k) => k.key) : Object.keys(rule.params)) :
+                        [];
+                    const validateArgs = rule.params ? Cast.schema(rule.params) : null;
+
+                    type.prototype[rule.name] = function () { // eslint-disable-line no-loop-func
+
+                        if (arguments.length > ruleArgs.length) {
+                            throw new Error('Unexpected number of arguments');
+                        }
+
+                        const args = Array.prototype.slice.call(arguments);
+                        let hasRef = false;
+                        const arg = {};
+
+                        for (let k = 0; k < ruleArgs.length; ++k) {
+                            arg[ruleArgs[k]] = args[k];
+                            if (!hasRef && Ref.isRef(args[k])) {
+                                hasRef = true;
+                            }
+                        }
+
+                        if (validateArgs) {
+                            joi.assert(arg, validateArgs);
+                        }
+
+                        let schema;
+                        if (rule.validate) {
+                            const validate = rule.validate.bind(this, arg);
+
+                            schema = this._test(rule.name, arg, validate, {
+                                description: rule.description,
+                                hasRef
+                            });
+                        }
+                        else {
+                            schema = this.clone();
+                        }
+
+                        if (rule.setup) {
+                            rule.setup.call(schema, arg);
+                        }
+
+                        return schema;
+                    };
+                }
+            }
+
+            if (extension.describe) {
+                type.prototype.describe = function () {
+
+                    const description = ctor.prototype.describe.call(this);
+                    return extension.describe.call(this, description);
+                };
+            }
+
+            const instance = new type();
+            joi[extension.name] = function () {
+
+                return instance;
+            };
+        }
+
+        return joi;
     };
 
     return root;
 };
 
 
+internals.extensionsSchema = internals.array.items(internals.object.keys({
+    base: internals.object.type(Any, 'Joi object'),
+    name: internals.string.required(),
+    pre: internals.object._func().arity(3),
+    language: internals.object,
+    describe: internals.object._func().arity(1),
+    rules: internals.array.items(internals.object.keys({
+        name: internals.string.required(),
+        setup: internals.object._func().arity(1),
+        validate: internals.object._func().arity(4),
+        params: [
+            internals.object.pattern(/.*/, internals.object.type(Any, 'Joi object')),
+            internals.object.type(internals.object.constructor, 'Joi object')
+        ],
+        description: [internals.string, internals.object._func().arity(1)]
+    }).or('setup', 'validate'))
+})).strict();
+
+
 module.exports = internals.root();

package/lib/language.js

@@ -68,11 +68,8 @@ exports.errors = {
         base: 'must be a Function',
         arity: 'must have an arity of {{n}}',
         minArity: 'must have an arity greater or equal to {{n}}',
-        maxArity: 'must have an arity lesser or equal to {{n}}'
-    },
-    lazy: {
-        base: '!!schema error: lazy schema must be set',
-        schema: '!!schema error: lazy schema function must return a schema'
+        maxArity: 'must have an arity lesser or equal to {{n}}',
+        ref: 'must be a Joi reference'
     },
     object: {
         base: 'must be an object',