joi 8.4.2 → 9.0.0-0

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

@@ -55,7 +55,6 @@ exports.errors = {
     },
     date: {
         base: 'must be a number of milliseconds or valid date string',
-        strict: 'must be a valid date',
         min: 'must be larger than or equal to "{{limit}}"',
         max: 'must be less than or equal to "{{limit}}"',
         isoDate: 'must be a valid ISO 8601 date',
@@ -69,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',

package/lib/object.js

@@ -6,6 +6,7 @@ const Hoek = require('hoek');
 const Topo = require('topo');
 const Any = require('./any');
 const Cast = require('./cast');
+const Ref = require('./ref');
 
 
 // Declare internals
@@ -25,15 +26,6 @@ internals.Object = function () {
 
 Hoek.inherits(internals.Object, Any);
 
-internals.safeParse = function (value) {
-
-    try {
-        return JSON.parse(value);
-    }
-    catch (parseErr) {}
-
-    return value;
-};
 
 internals.Object.prototype._base = function (value, state, options) {
 
@@ -50,7 +42,10 @@ internals.Object.prototype._base = function (value, state, options) {
     if (typeof value === 'string' &&
         options.convert) {
 
-        value = internals.safeParse(value);
+        try {
+            value = JSON.parse(value);
+        }
+        catch (parseErr) { }
     }
 
     const type = this._flags.func ? 'function' : 'object';
@@ -101,42 +96,42 @@ internals.Object.prototype._base = function (value, state, options) {
 
     const renamed = {};
     for (let i = 0; i < this._inner.renames.length; ++i) {
-        const rename = this._inner.renames[i];
+        const item = this._inner.renames[i];
 
-        if (rename.options.ignoreUndefined && target[rename.from] === undefined) {
+        if (item.options.ignoreUndefined && target[item.from] === undefined) {
             continue;
         }
 
-        if (!rename.options.multiple &&
-            renamed[rename.to]) {
+        if (!item.options.multiple &&
+            renamed[item.to]) {
 
-            errors.push(this.createError('object.rename.multiple', { from: rename.from, to: rename.to }, state, options));
+            errors.push(this.createError('object.rename.multiple', { from: item.from, to: item.to }, state, options));
             if (options.abortEarly) {
                 return finish();
             }
         }
 
-        if (Object.prototype.hasOwnProperty.call(target, rename.to) &&
-            !rename.options.override &&
-            !renamed[rename.to]) {
+        if (Object.prototype.hasOwnProperty.call(target, item.to) &&
+            !item.options.override &&
+            !renamed[item.to]) {
 
-            errors.push(this.createError('object.rename.override', { from: rename.from, to: rename.to }, state, options));
+            errors.push(this.createError('object.rename.override', { from: item.from, to: item.to }, state, options));
             if (options.abortEarly) {
                 return finish();
             }
         }
 
-        if (target[rename.from] === undefined) {
-            delete target[rename.to];
+        if (target[item.from] === undefined) {
+            delete target[item.to];
         }
         else {
-            target[rename.to] = target[rename.from];
+            target[item.to] = target[item.from];
         }
 
-        renamed[rename.to] = true;
+        renamed[item.to] = true;
 
-        if (!rename.options.alias) {
-            delete target[rename.from];
+        if (!item.options.alias) {
+            delete target[item.from];
         }
     }
 
@@ -191,8 +186,6 @@ internals.Object.prototype._base = function (value, state, options) {
 
         for (let i = 0; i < unprocessedKeys.length; ++i) {
             const key = unprocessedKeys[i];
-            const localState = { key, path: (state.path ? state.path + '.' : '') + 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];
@@ -200,6 +193,8 @@ internals.Object.prototype._base = function (value, state, options) {
                 if (pattern.regex.test(key)) {
                     delete unprocessed[key];
 
+                    const item = target[key];
+                    const localState = { key, path: (state.path ? state.path + '.' : '') + key, parent: target, reference: state.reference };
                     const result = pattern.rule._validate(item, localState, options);
                     if (result.errors) {
                         errors.push(this.createError('object.child', { key, reason: result.errors }, localState, options));
@@ -223,15 +218,10 @@ internals.Object.prototype._base = function (value, state, options) {
         if (options.stripUnknown ||
             options.skipFunctions) {
 
-            const stripUnknown = options.stripUnknown
-                ? (options.stripUnknown === true ? true : !!options.stripUnknown.objects)
-                : false;
-
-
             for (let i = 0; i < unprocessedKeys.length; ++i) {
                 const key = unprocessedKeys[i];
 
-                if (stripUnknown) {
+                if (options.stripUnknown) {
                     delete target[key];
                     delete unprocessed[key];
                 }
@@ -823,4 +813,17 @@ internals.Object.prototype.type = function (constructor, name) {
 };
 
 
+internals.Object.prototype.ref = function () {
+
+    return this._test('ref', null, (value, state, options) => {
+
+        if (Ref.isRef(value)) {
+            return null;
+        }
+
+        return this.createError('function.ref', null, state, options);
+    });
+};
+
+
 module.exports = new internals.Object();

package/lib/string.js

@@ -79,16 +79,6 @@ internals.String.prototype._base = function (value, state, options) {
                 value = value.replace(replacement.pattern, replacement.replacement);
             }
         }
-
-        if (this._flags.truncate) {
-            for (let i = 0; i < this._tests.length; ++i) {
-                const test = this._tests[i];
-                if (test.name === 'max') {
-                    value = value.slice(0, test.arg);
-                    break;
-                }
-            }
-        }
     }
 
     return {
@@ -481,11 +471,4 @@ internals.String.prototype.replace = function (pattern, replacement) {
     return obj;
 };
 
-internals.String.prototype.truncate = function (enabled) {
-
-    const obj = this.clone();
-    obj._flags.truncate = enabled === undefined ? true : !!enabled;
-    return obj;
-};
-
 module.exports = new internals.String();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "joi",
   "description": "Object schema validation",
-  "version": "8.4.2",
+  "version": "9.0.0-0",
   "homepage": "https://github.com/hapijs/joi",
   "repository": "git://github.com/hapijs/joi",
   "main": "lib/index.js",
@@ -15,18 +15,18 @@
   },
   "dependencies": {
     "hoek": "4.x.x",
-    "topo": "2.x.x",
     "isemail": "2.x.x",
-    "moment": "2.x.x"
+    "items": "2.x.x",
+    "moment": "2.x.x",
+    "topo": "2.x.x"
   },
   "devDependencies": {
-    "code": "3.x.x",
+    "code": "2.x.x",
     "lab": "10.x.x",
     "markdown-toc": "0.12.x"
   },
   "scripts": {
     "test": "lab -t 100 -a code -L",
-    "test-debug": "node $NODE_DEBUG_OPTION ./node_modules/.bin/lab -a code",
     "test-cov-html": "lab -r html -o coverage.html -a code",
     "toc": "node generate-readme-toc.js",
     "version": "npm run toc && git add API.md README.md"