joi 14.2.0 → 17.2.0

package/lib/index.js

@@ -1,450 +1,282 @@
 'use strict';
 
-// Load modules
+const Assert = require('@hapi/hoek/lib/assert');
+const Clone = require('@hapi/hoek/lib/clone');
 
-const Hoek = require('hoek');
-const Any = require('./types/any');
-const Cast = require('./cast');
+const Cache = require('./cache');
+const Common = require('./common');
+const Compile = require('./compile');
 const Errors = require('./errors');
-const Lazy = require('./types/lazy');
+const Extend = require('./extend');
+const Manifest = require('./manifest');
 const Ref = require('./ref');
-const Settings = require('./types/any/settings');
+const Template = require('./template');
+const Trace = require('./trace');
 
+let Schemas;
 
-// Declare internals
 
 const internals = {
-    alternatives: require('./types/alternatives'),
-    array: require('./types/array'),
-    boolean: require('./types/boolean'),
-    binary: require('./types/binary'),
-    date: require('./types/date'),
-    func: require('./types/func'),
-    number: require('./types/number'),
-    object: require('./types/object'),
-    string: require('./types/string'),
-    symbol: require('./types/symbol')
-};
-
-internals.callWithDefaults = function (schema, args) {
-
-    Hoek.assert(this, 'Must be invoked on a Joi instance.');
-
-    if (this._defaults) {
-        schema = this._defaults(schema);
+    types: {
+        alternatives: require('./types/alternatives'),
+        any: require('./types/any'),
+        array: require('./types/array'),
+        boolean: require('./types/boolean'),
+        date: require('./types/date'),
+        function: require('./types/function'),
+        link: require('./types/link'),
+        number: require('./types/number'),
+        object: require('./types/object'),
+        string: require('./types/string'),
+        symbol: require('./types/symbol')
+    },
+    aliases: {
+        alt: 'alternatives',
+        bool: 'boolean',
+        func: 'function'
     }
-
-    schema._currentJoi = this;
-
-    return schema._init(...args);
 };
 
-internals.root = function () {
-
-    const any = new Any();
-
-    const root = any.clone();
-    Any.prototype._currentJoi = root;
-    root._currentJoi = root;
-
-    root.any = function (...args) {
-
-        Hoek.assert(args.length === 0, 'Joi.any() does not allow arguments.');
-
-        return internals.callWithDefaults.call(this, any, args);
-    };
-
-    root.alternatives = root.alt = function (...args) {
 
-        return internals.callWithDefaults.call(this, internals.alternatives, args);
-    };
-
-    root.array = function (...args) {
+if (Buffer) {                                                           // $lab:coverage:ignore$
+    internals.types.binary = require('./types/binary');
+}
 
-        Hoek.assert(args.length === 0, 'Joi.array() does not allow arguments.');
-
-        return internals.callWithDefaults.call(this, internals.array, args);
-    };
 
-    root.boolean = root.bool = function (...args) {
-
-        Hoek.assert(args.length === 0, 'Joi.boolean() does not allow arguments.');
+internals.root = function () {
 
-        return internals.callWithDefaults.call(this, internals.boolean, args);
+    const root = {
+        _types: new Set(Object.keys(internals.types))
     };
 
-    root.binary = function (...args) {
-
-        Hoek.assert(args.length === 0, 'Joi.binary() does not allow arguments.');
+    // Types
 
-        return internals.callWithDefaults.call(this, internals.binary, args);
-    };
+    for (const type of root._types) {
+        root[type] = function (...args) {
 
-    root.date = function (...args) {
+            Assert(!args.length || ['alternatives', 'link', 'object'].includes(type), 'The', type, 'type does not allow arguments');
+            return internals.generate(this, internals.types[type], args);
+        };
+    }
 
-        Hoek.assert(args.length === 0, 'Joi.date() does not allow arguments.');
+    // Shortcuts
 
-        return internals.callWithDefaults.call(this, internals.date, args);
-    };
+    for (const method of ['allow', 'custom', 'disallow', 'equal', 'exist', 'forbidden', 'invalid', 'not', 'only', 'optional', 'options', 'prefs', 'preferences', 'required', 'strip', 'valid', 'when']) {
+        root[method] = function (...args) {
 
-    root.func = function (...args) {
+            return this.any()[method](...args);
+        };
+    }
 
-        Hoek.assert(args.length === 0, 'Joi.func() does not allow arguments.');
+    // Methods
 
-        return internals.callWithDefaults.call(this, internals.func, args);
-    };
+    Object.assign(root, internals.methods);
 
-    root.number = function (...args) {
+    // Aliases
 
-        Hoek.assert(args.length === 0, 'Joi.number() does not allow arguments.');
+    for (const alias in internals.aliases) {
+        const target = internals.aliases[alias];
+        root[alias] = root[target];
+    }
 
-        return internals.callWithDefaults.call(this, internals.number, args);
-    };
+    root.x = root.expression;
 
-    root.object = function (...args) {
+    // Trace
 
-        return internals.callWithDefaults.call(this, internals.object, args);
-    };
+    if (Trace.setup) {                                          // $lab:coverage:ignore$
+        Trace.setup(root);
+    }
 
-    root.string = function (...args) {
+    return root;
+};
 
-        Hoek.assert(args.length === 0, 'Joi.string() does not allow arguments.');
 
-        return internals.callWithDefaults.call(this, internals.string, args);
-    };
+internals.methods = {
 
-    root.symbol = function (...args) {
+    ValidationError: Errors.ValidationError,
+    version: Common.version,
+    cache: Cache.provider,
 
-        Hoek.assert(args.length === 0, 'Joi.symbol() does not allow arguments.');
+    assert(value, schema, ...args /* [message], [options] */) {
 
-        return internals.callWithDefaults.call(this, internals.symbol, args);
-    };
+        internals.assert(value, schema, true, args);
+    },
 
-    root.ref = function (...args) {
+    attempt(value, schema, ...args /* [message], [options] */) {
 
-        return Ref.create(...args);
-    };
+        return internals.assert(value, schema, false, args);
+    },
 
-    root.isRef = function (ref) {
+    build(desc) {
 
-        return Ref.isRef(ref);
-    };
+        Assert(typeof Manifest.build === 'function', 'Manifest functionality disabled');
+        return Manifest.build(this, desc);
+    },
 
-    root.validate = function (value, ...args /*, [schema], [options], callback */) {
+    checkPreferences(prefs) {
 
-        const last = args[args.length - 1];
-        const callback = typeof last === 'function' ? last : null;
+        Common.checkPreferences(prefs);
+    },
 
-        const count = args.length - (callback ? 1 : 0);
-        if (count === 0) {
-            return any.validate(value, callback);
-        }
+    compile(schema, options) {
 
-        const options = count === 2 ? args[1] : undefined;
-        const schema = root.compile(args[0]);
+        return Compile.compile(this, schema, options);
+    },
 
-        return schema._validateWithOptions(value, options, callback);
-    };
+    defaults(modifier) {
 
-    root.describe = function (...args) {
+        Assert(typeof modifier === 'function', 'modifier must be a function');
 
-        const schema = args.length ? root.compile(args[0]) : any;
-        return schema.describe();
-    };
+        const joi = Object.assign({}, this);
+        for (const type of joi._types) {
+            const schema = modifier(joi[type]());
+            Assert(Common.isSchema(schema), 'modifier must return a valid schema object');
 
-    root.compile = function (schema) {
+            joi[type] = function (...args) {
 
-        try {
-            return Cast.schema(this, schema);
-        }
-        catch (err) {
-            if (err.hasOwnProperty('path')) {
-                err.message = err.message + '(' + err.path + ')';
-            }
-
-            throw err;
+                return internals.generate(this, schema, args);
+            };
         }
-    };
-
-    root.assert = function (value, schema, message) {
-
-        root.attempt(value, schema, message);
-    };
-
-    root.attempt = function (value, schema, message) {
-
-        const result = root.validate(value, schema);
-        const error = result.error;
-        if (error) {
-            if (!message) {
-                if (typeof error.annotate === 'function') {
-                    error.message = error.annotate();
-                }
-
-                throw error;
-            }
-
-            if (!(message instanceof Error)) {
-                if (typeof error.annotate === 'function') {
-                    error.message = `${message} ${error.annotate()}`;
-                }
 
-                throw error;
-            }
+        return joi;
+    },
 
-            throw message;
-        }
+    expression(...args) {
 
-        return result.value;
-    };
+        return new Template(...args);
+    },
 
-    root.reach = function (schema, path) {
+    extend(...extensions) {
 
-        Hoek.assert(schema && schema instanceof Any, 'you must provide a joi schema');
-        Hoek.assert(Array.isArray(path) || typeof path === 'string', 'path must be a string or an array of strings');
+        Common.verifyFlat(extensions, 'extend');
 
-        const reach = (sourceSchema, schemaPath) => {
+        Schemas = Schemas || require('./schemas');
 
-            if (!schemaPath.length) {
-                return sourceSchema;
-            }
+        Assert(extensions.length, 'You need to provide at least one extension');
+        this.assert(extensions, Schemas.extensions);
 
-            const children = sourceSchema._inner.children;
-            if (!children) {
-                return;
-            }
+        const joi = Object.assign({}, this);
+        joi._types = new Set(joi._types);
 
-            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);
-                }
+        for (let extension of extensions) {
+            if (typeof extension === 'function') {
+                extension = extension(joi);
             }
-        };
 
-        const schemaPath = typeof path === 'string' ? (path ? path.split('.') : []) : path.slice();
+            this.assert(extension, Schemas.extension);
 
-        return reach(schema, schemaPath);
-    };
-
-    root.lazy = function (...args) {
-
-        return internals.callWithDefaults.call(this, Lazy, args);
-    };
+            const expanded = internals.expandExtension(extension, joi);
+            for (const item of expanded) {
+                Assert(joi[item.type] === undefined || joi._types.has(item.type), 'Cannot override name', item.type);
 
-    root.defaults = function (fn) {
+                const base = item.base || this.any();
+                const schema = Extend.type(base, item);
 
-        Hoek.assert(typeof fn === 'function', 'Defaults must be a function');
+                joi._types.add(item.type);
+                joi[item.type] = function (...args) {
 
-        let joi = Object.create(this.any());
-        joi = fn(joi);
-
-        Hoek.assert(joi && joi instanceof this.constructor, 'defaults() must return a schema');
-
-        Object.assign(joi, this, joi.clone()); // Re-add the types from `this` but also keep the settings from joi's potential new defaults
-
-        joi._defaults = (schema) => {
-
-            if (this._defaults) {
-                schema = this._defaults(schema);
-                Hoek.assert(schema instanceof this.constructor, 'defaults() must return a schema');
+                    return internals.generate(this, schema, args);
+                };
             }
-
-            schema = fn(schema);
-            Hoek.assert(schema instanceof this.constructor, 'defaults() must return a schema');
-            return schema;
-        };
+        }
 
         return joi;
-    };
+    },
 
-    root.extend = function (...args) {
+    isError: Errors.ValidationError.isError,
+    isExpression: Template.isTemplate,
+    isRef: Ref.isRef,
+    isSchema: Common.isSchema,
 
-        const extensions = Hoek.flatten(args);
-        Hoek.assert(extensions.length > 0, 'You need to provide at least one extension');
+    in(...args) {
 
-        this.assert(extensions, root.extensionsSchema);
+        return Ref.in(...args);
+    },
 
-        const joi = Object.create(this.any());
-        Object.assign(joi, this);
+    override: Common.symbols.override,
 
-        for (let i = 0; i < extensions.length; ++i) {
-            let extension = extensions[i];
+    ref(...args) {
 
-            if (typeof extension === 'function') {
-                extension = extension(joi);
-            }
+        return Ref.create(...args);
+    },
 
-            this.assert(extension, root.extensionSchema);
+    types() {
 
-            const base = (extension.base || this.any()).clone(); // Cloning because we're going to override language afterwards
-            const ctor = base.constructor;
-            const type = class extends ctor { // eslint-disable-line no-loop-func
+        const types = {};
+        for (const type of this._types) {
+            types[type] = this[type]();
+        }
 
-                constructor() {
+        for (const target in internals.aliases) {
+            types[target] = this[target]();
+        }
 
-                    super();
-                    if (extension.base) {
-                        Object.assign(this, base);
-                    }
+        return types;
+    }
+};
 
-                    this._type = extension.name;
 
-                    if (extension.language) {
-                        this._settings = Settings.concat(this._settings, {
-                            language: {
-                                [extension.name]: extension.language
-                            }
-                        });
-                    }
-                }
+// Helpers
 
-            };
+internals.assert = function (value, schema, annotate, args /* [message], [options] */) {
 
-            if (extension.coerce) {
-                type.prototype._coerce = function (value, state, options) {
+    const message = args[0] instanceof Error || typeof args[0] === 'string' ? args[0] : null;
+    const options = message ? args[1] : args[0];
+    const result = schema.validate(value, Common.preferences({ errors: { stack: true } }, options || {}));
 
-                    if (ctor.prototype._coerce) {
-                        const baseRet = ctor.prototype._coerce.call(this, value, state, options);
+    let error = result.error;
+    if (!error) {
+        return result.value;
+    }
 
-                        if (baseRet.errors) {
-                            return baseRet;
-                        }
+    if (message instanceof Error) {
+        throw message;
+    }
 
-                        value = baseRet.value;
-                    }
+    const display = annotate && typeof error.annotate === 'function' ? error.annotate() : error.message;
 
-                    const ret = extension.coerce.call(this, value, state, options);
-                    if (ret instanceof Errors.Err) {
-                        return { value, errors: ret };
-                    }
+    if (error instanceof Errors.ValidationError === false) {
+        error = Clone(error);
+    }
 
-                    return { value: ret };
-                };
-            }
+    error.message = message ? `${message} ${display}` : display;
+    throw error;
+};
 
-            if (extension.pre) {
-                type.prototype._base = function (value, state, options) {
 
-                    if (ctor.prototype._base) {
-                        const baseRet = ctor.prototype._base.call(this, value, state, options);
+internals.generate = function (root, schema, args) {
 
-                        if (baseRet.errors) {
-                            return baseRet;
-                        }
+    Assert(root, 'Must be invoked on a Joi instance.');
 
-                        value = baseRet.value;
-                    }
+    schema.$_root = root;
 
-                    const ret = extension.pre.call(this, value, state, options);
-                    if (ret instanceof Errors.Err) {
-                        return { value, errors: ret };
-                    }
+    if (!schema._definition.args ||
+        !args.length) {
 
-                    return { value: ret };
-                };
-            }
+        return schema;
+    }
 
-            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(this, rule.params) : null;
-
-                    type.prototype[rule.name] = function (...rArgs) { // eslint-disable-line no-loop-func
-
-                        if (rArgs.length > ruleArgs.length) {
-                            throw new Error('Unexpected number of arguments');
-                        }
-
-                        let hasRef = false;
-                        let arg = {};
-
-                        for (let k = 0; k < ruleArgs.length; ++k) {
-                            arg[ruleArgs[k]] = rArgs[k];
-                            if (!hasRef && Ref.isRef(rArgs[k])) {
-                                hasRef = true;
-                            }
-                        }
-
-                        if (validateArgs) {
-                            arg = joi.attempt(arg, validateArgs);
-                        }
-
-                        let schema;
-                        if (rule.validate) {
-                            const validate = function (value, state, options) {
-
-                                return rule.validate.call(this, arg, value, state, options);
-                            };
-
-                            schema = this._test(rule.name, arg, validate, {
-                                description: rule.description,
-                                hasRef
-                            });
-                        }
-                        else {
-                            schema = this.clone();
-                        }
-
-                        if (rule.setup) {
-                            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;
-                    };
-                }
-            }
+    return schema._definition.args(schema, ...args);
+};
 
-            if (extension.describe) {
-                type.prototype.describe = function () {
 
-                    const description = ctor.prototype.describe.call(this);
-                    return extension.describe.call(this, description);
-                };
-            }
+internals.expandExtension = function (extension, joi) {
 
-            const instance = new type();
-            joi[extension.name] = function (...extArgs) {
+    if (typeof extension.type === 'string') {
+        return [extension];
+    }
 
-                return internals.callWithDefaults.call(this, instance, extArgs);
-            };
+    const extended = [];
+    for (const type of joi._types) {
+        if (extension.type.test(type)) {
+            const item = Object.assign({}, extension);
+            item.type = type;
+            item.base = joi[type]();
+            extended.push(item);
         }
+    }
 
-        return joi;
-    };
-
-    root.extensionSchema = internals.object.keys({
-        base: internals.object.type(Any, 'Joi object'),
-        name: internals.string.required(),
-        coerce: internals.func.arity(3),
-        pre: internals.func.arity(3),
-        language: internals.object,
-        describe: internals.func.arity(1),
-        rules: internals.array.items(internals.object.keys({
-            name: internals.string.required(),
-            setup: internals.func.arity(1),
-            validate: internals.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.func.arity(1)]
-        }).or('setup', 'validate'))
-    }).strict();
-
-    root.extensionsSchema = internals.array.items([internals.object, internals.func.arity(1)]).strict();
-
-    root.version = require('../package.json').version;
-
-    return root;
+    return extended;
 };