joi 17.13.2 → 18.0.0

package/lib/annotate.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Clone = require('@hapi/hoek/lib/clone');
+const { clone } = require('@hapi/hoek');
 
 const Common = require('./common');
 
@@ -22,7 +22,7 @@ exports.error = function (stripColorCodes) {
     const redBgEscape = stripColorCodes ? '' : '\u001b[41m';
     const endColor = stripColorCodes ? '' : '\u001b[0m';
 
-    const obj = Clone(this._original);
+    const obj = clone(this._original);
 
     for (let i = this.details.length - 1; i >= 0; --i) {        // Reverse order to process deepest child first
         const pos = i + 1;

package/lib/base.js

@@ -1,9 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
-const DeepEqual = require('@hapi/hoek/lib/deepEqual');
-const Merge = require('@hapi/hoek/lib/merge');
+const { assert, clone, deepEqual, merge } = require('@hapi/hoek');
 
 const Cache = require('./cache');
 const Common = require('./common');
@@ -61,7 +58,7 @@ internals.Base = class {
 
     describe() {
 
-        Assert(typeof Manifest.describe === 'function', 'Manifest functionality disabled');
+        assert(typeof Manifest.describe === 'function', 'Manifest functionality disabled');
         return Manifest.describe(this);
     }
 
@@ -75,14 +72,14 @@ internals.Base = class {
 
     alter(targets) {
 
-        Assert(targets && typeof targets === 'object' && !Array.isArray(targets), 'Invalid targets argument');
-        Assert(!this._inRuleset(), 'Cannot set alterations inside a ruleset');
+        assert(targets && typeof targets === 'object' && !Array.isArray(targets), 'Invalid targets argument');
+        assert(!this._inRuleset(), 'Cannot set alterations inside a ruleset');
 
         const obj = this.clone();
         obj.$_terms.alterations = obj.$_terms.alterations || [];
         for (const target in targets) {
             const adjuster = targets[target];
-            Assert(typeof adjuster === 'function', 'Alteration adjuster for', target, 'must be a function');
+            assert(typeof adjuster === 'function', 'Alteration adjuster for', target, 'must be a function');
             obj.$_terms.alterations.push({ target, adjuster });
         }
 
@@ -92,16 +89,16 @@ internals.Base = class {
 
     artifact(id) {
 
-        Assert(id !== undefined, 'Artifact cannot be undefined');
-        Assert(!this._cache, 'Cannot set an artifact with a rule cache');
+        assert(id !== undefined, 'Artifact cannot be undefined');
+        assert(!this._cache, 'Cannot set an artifact with a rule cache');
 
         return this.$_setFlag('artifact', id);
     }
 
     cast(to) {
 
-        Assert(to === false || typeof to === 'string', 'Invalid to value');
-        Assert(to === false || this._definition.cast[to], 'Type', this.type, 'does not support casting to', to);
+        assert(to === false || typeof to === 'string', 'Invalid to value');
+        assert(to === false || this._definition.cast[to], 'Type', this.type, 'does not support casting to', to);
 
         return this.$_setFlag('cast', to === false ? undefined : to);
     }
@@ -113,7 +110,7 @@ internals.Base = class {
 
     description(desc) {
 
-        Assert(desc && typeof desc === 'string', 'Description must be a non-empty string');
+        assert(desc && typeof desc === 'string', 'Description must be a non-empty string');
 
         return this.$_setFlag('description', desc);
     }
@@ -131,15 +128,15 @@ internals.Base = class {
 
     error(err) {
 
-        Assert(err, 'Missing error');
-        Assert(err instanceof Error || typeof err === 'function', 'Must provide a valid Error object or a function');
+        assert(err, 'Missing error');
+        assert(err instanceof Error || typeof err === 'function', 'Must provide a valid Error object or a function');
 
         return this.$_setFlag('error', err);
     }
 
     example(example, options = {}) {
 
-        Assert(example !== undefined, 'Missing example');
+        assert(example !== undefined, 'Missing example');
         Common.assertOptions(options, ['override']);
 
         return this._inner('examples', example, { single: true, override: options.override });
@@ -148,13 +145,13 @@ internals.Base = class {
     external(method, description) {
 
         if (typeof method === 'object') {
-            Assert(!description, 'Cannot combine options with description');
+            assert(!description, 'Cannot combine options with description');
             description = method.description;
             method = method.method;
         }
 
-        Assert(typeof method === 'function', 'Method must be a function');
-        Assert(description === undefined || description && typeof description === 'string', 'Description must be a non-empty string');
+        assert(typeof method === 'function', 'Method must be a function');
+        assert(description === undefined || description && typeof description === 'string', 'Description must be a non-empty string');
 
         return this._inner('externals', { method, description }, { single: true });
     }
@@ -175,8 +172,8 @@ internals.Base = class {
             return this.$_setFlag('id', undefined);
         }
 
-        Assert(typeof id === 'string', 'id must be a non-empty string');
-        Assert(/^[^\.]+$/.test(id), 'id cannot contain period character');
+        assert(typeof id === 'string', 'id must be a non-empty string');
+        assert(/^[^\.]+$/.test(id), 'id cannot contain period character');
 
         return this.$_setFlag('id', id);
     }
@@ -188,23 +185,23 @@ internals.Base = class {
 
     label(name) {
 
-        Assert(name && typeof name === 'string', 'Label name must be a non-empty string');
+        assert(name && typeof name === 'string', 'Label name must be a non-empty string');
 
         return this.$_setFlag('label', name);
     }
 
     meta(meta) {
 
-        Assert(meta !== undefined, 'Meta cannot be undefined');
+        assert(meta !== undefined, 'Meta cannot be undefined');
 
         return this._inner('metas', meta, { single: true });
     }
 
     note(...notes) {
 
-        Assert(notes.length, 'Missing notes');
+        assert(notes.length, 'Missing notes');
         for (const note of notes) {
-            Assert(note && typeof note === 'string', 'Notes must be non-empty strings');
+            assert(note && typeof note === 'string', 'Notes must be non-empty strings');
         }
 
         return this._inner('notes', notes);
@@ -212,7 +209,7 @@ internals.Base = class {
 
     only(mode = true) {
 
-        Assert(typeof mode === 'boolean', 'Invalid mode:', mode);
+        assert(typeof mode === 'boolean', 'Invalid mode:', mode);
 
         return this.$_setFlag('only', mode);
     }
@@ -224,11 +221,11 @@ internals.Base = class {
 
     prefs(prefs) {
 
-        Assert(prefs, 'Missing preferences');
-        Assert(prefs.context === undefined, 'Cannot override context');
-        Assert(prefs.externals === undefined, 'Cannot override externals');
-        Assert(prefs.warnings === undefined, 'Cannot override warnings');
-        Assert(prefs.debug === undefined, 'Cannot override debug');
+        assert(prefs, 'Missing preferences');
+        assert(prefs.context === undefined, 'Cannot override context');
+        assert(prefs.externals === undefined, 'Cannot override externals');
+        assert(prefs.warnings === undefined, 'Cannot override warnings');
+        assert(prefs.debug === undefined, 'Cannot override debug');
 
         Common.checkPreferences(prefs);
 
@@ -239,7 +236,7 @@ internals.Base = class {
 
     presence(mode) {
 
-        Assert(['optional', 'required', 'forbidden'].includes(mode), 'Unknown presence mode', mode);
+        assert(['optional', 'required', 'forbidden'].includes(mode), 'Unknown presence mode', mode);
 
         return this.$_setFlag('presence', mode);
     }
@@ -251,7 +248,7 @@ internals.Base = class {
 
     result(mode) {
 
-        Assert(['raw', 'strip'].includes(mode), 'Unknown result mode', mode);
+        assert(['raw', 'strip'].includes(mode), 'Unknown result mode', mode);
 
         return this.$_setFlag('result', mode);
     }
@@ -277,9 +274,9 @@ internals.Base = class {
 
     tag(...tags) {
 
-        Assert(tags.length, 'Missing tags');
+        assert(tags.length, 'Missing tags');
         for (const tag of tags) {
-            Assert(tag && typeof tag === 'string', 'Tags must be non-empty strings');
+            assert(tag && typeof tag === 'string', 'Tags must be non-empty strings');
         }
 
         return this._inner('tags', tags);
@@ -287,7 +284,7 @@ internals.Base = class {
 
     unit(name) {
 
-        Assert(name && typeof name === 'string', 'Unit name must be a non-empty string');
+        assert(name && typeof name === 'string', 'Unit name must be a non-empty string');
 
         return this.$_setFlag('unit', name);
     }
@@ -313,8 +310,8 @@ internals.Base = class {
         if (!['any', 'link'].includes(obj.type)) {
             const conditions = when.is ? [when] : when.switch;
             for (const item of conditions) {
-                Assert(!item.then || item.then.type === 'any' || item.then.type === obj.type, 'Cannot combine', obj.type, 'with', item.then && item.then.type);
-                Assert(!item.otherwise || item.otherwise.type === 'any' || item.otherwise.type === obj.type, 'Cannot combine', obj.type, 'with', item.otherwise && item.otherwise.type);
+                assert(!item.then || item.then.type === 'any' || item.then.type === obj.type, 'Cannot combine', obj.type, 'with', item.then && item.then.type);
+                assert(!item.otherwise || item.otherwise.type === 'any' || item.otherwise.type === obj.type, 'Cannot combine', obj.type, 'with', item.otherwise && item.otherwise.type);
 
             }
         }
@@ -327,9 +324,9 @@ internals.Base = class {
 
     cache(cache) {
 
-        Assert(!this._inRuleset(), 'Cannot set caching inside a ruleset');
-        Assert(!this._cache, 'Cannot override schema cache');
-        Assert(this._flags.artifact === undefined, 'Cannot cache a rule with an artifact');
+        assert(!this._inRuleset(), 'Cannot set caching inside a ruleset');
+        assert(!this._cache, 'Cannot override schema cache');
+        assert(this._flags.artifact === undefined, 'Cannot cache a rule with an artifact');
 
         const obj = this.clone();
         obj._cache = cache || Cache.provider.provision();
@@ -345,10 +342,10 @@ internals.Base = class {
 
     concat(source) {
 
-        Assert(Common.isSchema(source), 'Invalid schema object');
-        Assert(this.type === 'any' || source.type === 'any' || source.type === this.type, 'Cannot merge type', this.type, 'with another type:', source.type);
-        Assert(!this._inRuleset(), 'Cannot concatenate onto a schema with open ruleset');
-        Assert(!source._inRuleset(), 'Cannot concatenate a schema with open ruleset');
+        assert(Common.isSchema(source), 'Invalid schema object');
+        assert(this.type === 'any' || source.type === 'any' || source.type === this.type, 'Cannot merge type', this.type, 'with another type:', source.type);
+        assert(!this._inRuleset(), 'Cannot concatenate onto a schema with open ruleset');
+        assert(!source._inRuleset(), 'Cannot concatenate a schema with open ruleset');
 
         let obj = this.clone();
 
@@ -401,16 +398,16 @@ internals.Base = class {
             obj._flags.empty = obj._flags.empty.concat(source._flags.empty);
             const flags = Object.assign({}, source._flags);
             delete flags.empty;
-            Merge(obj._flags, flags);
+            merge(obj._flags, flags);
         }
         else if (source._flags.empty) {
             obj._flags.empty = source._flags.empty;
             const flags = Object.assign({}, source._flags);
             delete flags.empty;
-            Merge(obj._flags, flags);
+            merge(obj._flags, flags);
         }
         else {
-            Merge(obj._flags, source._flags);
+            merge(obj._flags, source._flags);
         }
 
         // Terms
@@ -446,7 +443,7 @@ internals.Base = class {
 
     extend(options) {
 
-        Assert(!options.base, 'Cannot extend type with another base');
+        assert(!options.base, 'Cannot extend type with another base');
 
         return Extend.type(this, options);
     }
@@ -459,7 +456,7 @@ internals.Base = class {
 
     fork(paths, adjuster) {
 
-        Assert(!this._inRuleset(), 'Cannot fork inside a ruleset');
+        assert(!this._inRuleset(), 'Cannot fork inside a ruleset');
 
         let obj = this;                                             // eslint-disable-line consistent-this
         for (let path of [].concat(paths)) {
@@ -471,24 +468,57 @@ internals.Base = class {
         return obj;
     }
 
+    isAsync() {
+
+        if (Boolean(this.$_terms.externals?.length)) {
+            return true;
+        }
+
+        if (this.$_terms.whens) {
+            for (const when of this.$_terms.whens) {
+                if (when.then?.isAsync()) {
+                    return true;
+                }
+
+                if (when.otherwise?.isAsync()) {
+                    return true;
+                }
+
+                if (when.switch) {
+                    for (const item of when.switch) {
+                        if (item.then?.isAsync()) {
+                            return true;
+                        }
+
+                        if (item.otherwise?.isAsync()) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
     rule(options) {
 
         const def = this._definition;
         Common.assertOptions(options, Object.keys(def.modifiers));
 
-        Assert(this.$_temp.ruleset !== false, 'Cannot apply rules to empty ruleset or the last rule added does not support rule properties');
+        assert(this.$_temp.ruleset !== false, 'Cannot apply rules to empty ruleset or the last rule added does not support rule properties');
         const start = this.$_temp.ruleset === null ? this._rules.length - 1 : this.$_temp.ruleset;
-        Assert(start >= 0 && start < this._rules.length, 'Cannot apply rules to empty ruleset');
+        assert(start >= 0 && start < this._rules.length, 'Cannot apply rules to empty ruleset');
 
         const obj = this.clone();
 
         for (let i = start; i < obj._rules.length; ++i) {
             const original = obj._rules[i];
-            const rule = Clone(original);
+            const rule = clone(original);
 
             for (const name in options) {
                 def.modifiers[name](rule, options[name]);
-                Assert(rule.name === original.name, 'Cannot change rule name');
+                assert(rule.name === original.name, 'Cannot change rule name');
             }
 
             obj._rules[i] = rule;
@@ -504,7 +534,7 @@ internals.Base = class {
 
     get ruleset() {
 
-        Assert(!this._inRuleset(), 'Cannot start a new ruleset without closing the previous one');
+        assert(!this._inRuleset(), 'Cannot start a new ruleset without closing the previous one');
 
         const obj = this.clone();
         obj.$_temp.ruleset = obj._rules.length;
@@ -520,7 +550,7 @@ internals.Base = class {
 
         targets = [].concat(targets);
 
-        Assert(!this._inRuleset(), 'Cannot tailor inside a ruleset');
+        assert(!this._inRuleset(), 'Cannot tailor inside a ruleset');
 
         let obj = this;                                                     // eslint-disable-line consistent-this
 
@@ -528,7 +558,7 @@ internals.Base = class {
             for (const { target, adjuster } of this.$_terms.alterations) {
                 if (targets.includes(target)) {
                     obj = adjuster(obj);
-                    Assert(Common.isSchema(obj), 'Alteration adjuster for', target, 'failed to return a schema object');
+                    assert(Common.isSchema(obj), 'Alteration adjuster for', target, 'failed to return a schema object');
                 }
             }
         }
@@ -563,11 +593,11 @@ internals.Base = class {
             options = { name: options };
         }
 
-        Assert(options && typeof options === 'object', 'Invalid options');
-        Assert(options.name && typeof options.name === 'string', 'Invalid rule name');
+        assert(options && typeof options === 'object', 'Invalid options');
+        assert(options.name && typeof options.name === 'string', 'Invalid rule name');
 
         for (const key in options) {
-            Assert(key[0] !== '_', 'Cannot set private rule properties');
+            assert(key[0] !== '_', 'Cannot set private rule properties');
         }
 
         const rule = Object.assign({}, options);        // Shallow cloned
@@ -577,14 +607,14 @@ internals.Base = class {
         const definition = this._definition.rules[rule.method];
         const args = rule.args;
 
-        Assert(definition, 'Unknown rule', rule.method);
+        assert(definition, 'Unknown rule', rule.method);
 
         // Args
 
         const obj = this.clone();
 
         if (args) {
-            Assert(Object.keys(args).length === 1 || Object.keys(args).length === this._definition.rules[rule.name].args.length, 'Invalid rule definition for', this.type, rule.name);
+            assert(Object.keys(args).length === 1 || Object.keys(args).length === this._definition.rules[rule.name].args.length, 'Invalid rule definition for', this.type, rule.name);
 
             for (const key in args) {
                 let arg = args[key];
@@ -606,7 +636,7 @@ internals.Base = class {
 
                         if (resolver.assert) {
                             const error = Common.validateArg(arg, key, resolver);
-                            Assert(!error, error, 'or reference');
+                            assert(!error, error, 'or reference');
                         }
                     }
                 }
@@ -690,7 +720,7 @@ internals.Base = class {
 
     $_mutateRebuild() {
 
-        Assert(!this._inRuleset(), 'Cannot add this rule inside a ruleset');
+        assert(!this._inRuleset(), 'Cannot add this rule inside a ruleset');
 
         this._refs.reset();
         this._ids.reset();
@@ -736,14 +766,14 @@ internals.Base = class {
 
     $_setFlag(name, value, options = {}) {
 
-        Assert(name[0] === '_' || !this._inRuleset(), 'Cannot set flag inside a ruleset');
+        assert(name[0] === '_' || !this._inRuleset(), 'Cannot set flag inside a ruleset');
 
         const flag = this._definition.flags[name] || {};
-        if (DeepEqual(value, flag.default)) {
+        if (deepEqual(value, flag.default)) {
             value = undefined;
         }
 
-        if (DeepEqual(value, this._flags[name])) {
+        if (deepEqual(value, this._flags[name])) {
             return this;
         }
 
@@ -790,7 +820,7 @@ internals.Base = class {
         target._valids = this._valids && this._valids.clone();
         target._invalids = this._invalids && this._invalids.clone();
         target._rules = this._rules.slice();
-        target._singleRules = Clone(this._singleRules, { shallow: true });
+        target._singleRules = clone(this._singleRules, { shallow: true });
         target._refs = this._refs.clone();
         target._flags = Object.assign({}, this._flags);
         target._cache = null;
@@ -828,8 +858,8 @@ internals.Base = class {
 
         Common.assertOptions(options, 'literal');
 
-        Assert(value !== undefined, 'Missing', flag, 'value');
-        Assert(typeof value === 'function' || !options.literal, 'Only function value supports literal option');
+        assert(value !== undefined, 'Missing', flag, 'value');
+        assert(typeof value === 'function' || !options.literal, 'Only function value supports literal option');
 
         if (typeof value === 'function' &&
             options.literal) {
@@ -938,7 +968,7 @@ internals.Base = class {
 
     _inner(type, values, options = {}) {
 
-        Assert(!this._inRuleset(), `Cannot set ${type} inside a ruleset`);
+        assert(!this._inRuleset(), `Cannot set ${type} inside a ruleset`);
 
         const obj = this.clone();
         if (!obj.$_terms[type] ||
@@ -1025,14 +1055,14 @@ internals.Base = class {
         }
 
         for (const value of values) {
-            Assert(value !== undefined, 'Cannot call allow/valid/invalid with undefined');
-            Assert(value !== Common.symbols.override, 'Override must be the first value');
+            assert(value !== undefined, 'Cannot call allow/valid/invalid with undefined');
+            assert(value !== Common.symbols.override, 'Override must be the first value');
 
             const other = key === '_invalids' ? '_valids' : '_invalids';
             if (obj[other]) {
                 obj[other].remove(value);
                 if (!obj[other].length) {
-                    Assert(key === '_valids' || !obj._flags.only, 'Setting invalid value', value, 'leaves schema rejecting all values due to previous valid rule');
+                    assert(key === '_valids' || !obj._flags.only, 'Setting invalid value', value, 'leaves schema rejecting all values due to previous valid rule');
                     obj[other] = null;
                 }
             }
@@ -1042,6 +1072,53 @@ internals.Base = class {
 
         return obj;
     }
+
+    // Standard Schema
+
+    get '~standard'() {
+
+        const mapToStandardError = (error) => {
+
+            let issues;
+            if (Errors.ValidationError.isError(error)) {
+                issues = error.details.map(({ message, path }) => ({
+                    message,
+                    path
+                }));
+            }
+            else {
+                issues = [{
+                    message: error.message
+                }];
+            }
+
+            return {
+                issues
+            };
+        };
+
+        const mapToStandardValue = (value) => ({ value });
+
+        return {
+            version: 1,
+            vendor: 'joi',
+            validate: (value) => {
+
+                const result = Validator.standard(value, this);
+
+                if (result instanceof Promise) {
+                    return result
+                        .then(mapToStandardValue, mapToStandardError);
+                }
+
+                if (!result.error) {
+                    return mapToStandardValue(result.value);
+                }
+
+                return mapToStandardError(result.error);
+            }
+        };
+    }
 };
 
 

package/lib/cache.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
+const { assert, clone } = require('@hapi/hoek');
 
 const Common = require('./common');
 
@@ -28,7 +27,7 @@ internals.Cache = class {
     constructor(options = {}) {
 
         Common.assertOptions(options, ['max']);
-        Assert(options.max === undefined || options.max && options.max > 0 && isFinite(options.max), 'Invalid max cache size');
+        assert(options.max === undefined || options.max && options.max > 0 && isFinite(options.max), 'Invalid max cache size');
 
         this._max = options.max || internals.max;
 
@@ -66,7 +65,7 @@ internals.Cache = class {
         const node = this._map.get(key);
         if (node) {
             this._list.first(node);
-            return Clone(node.value);
+            return clone(node.value);
         }
     }
 

package/lib/common.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const AssertError = require('@hapi/hoek/lib/error');
+const { assert: Assert, AssertError } = require('@hapi/hoek');
 
 const Pkg = require('../package.json');