joi 17.13.3 → 18.0.1

package/lib/types/any.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Base = require('../base');
 const Common = require('../common');
@@ -36,8 +36,8 @@ module.exports = Base.extend({
         custom: {
             method(method, description) {
 
-                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.$_addRule({ name: 'custom', args: { method, description } });
             },
@@ -64,7 +64,7 @@ module.exports = Base.extend({
         shared: {
             method(schema) {
 
-                Assert(Common.isSchema(schema) && schema._flags.id, 'Schema must be a schema with an id');
+                assert(Common.isSchema(schema) && schema._flags.id, 'Schema must be a schema with an id');
 
                 const obj = this.clone();
                 obj.$_terms.shared = obj.$_terms.shared || [];
@@ -77,7 +77,7 @@ module.exports = Base.extend({
         warning: {
             method(code, local) {
 
-                Assert(code && typeof code === 'string', 'Invalid warning code');
+                assert(code && typeof code === 'string', 'Invalid warning code');
 
                 return this.$_addRule({ name: 'warning', args: { code, local }, warn: true });
             },

package/lib/types/array.js

@@ -1,8 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
-const DeepEqual = require('@hapi/hoek/lib/deepEqual');
-const Reach = require('@hapi/hoek/lib/reach');
+const { assert, deepEqual, reach } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -417,7 +415,7 @@ module.exports = Any.extend({
             method(enabled) {
 
                 const value = enabled === undefined ? true : !!enabled;
-                Assert(!value || !this._flags._arrayItems, 'Cannot specify single rule when array has array items');
+                assert(!value || !this._flags._arrayItems, 'Cannot specify single rule when array has array items');
 
                 return this.$_setFlag('single', value);
             }
@@ -434,7 +432,7 @@ module.exports = Any.extend({
 
                 if (options.by) {
                     settings.by = Compile.ref(options.by, { ancestor: 0 });
-                    Assert(!settings.by.ancestor, 'Cannot sort by ancestor');
+                    assert(!settings.by.ancestor, 'Cannot sort by ancestor');
                 }
 
                 return this.$_addRule({ name: 'sort', args: { options: settings } });
@@ -474,7 +472,7 @@ module.exports = Any.extend({
         unique: {
             method(comparator, options = {}) {
 
-                Assert(!comparator || typeof comparator === 'function' || typeof comparator === 'string', 'comparator must be a function or a string');
+                assert(!comparator || typeof comparator === 'function' || typeof comparator === 'string', 'comparator must be a function or a string');
                 Common.assertOptions(options, ['ignoreUndefined', 'separator']);
 
                 const rule = { name: 'unique', args: { options, comparator } };
@@ -504,13 +502,13 @@ module.exports = Any.extend({
                     custom: new Map()
                 };
 
-                const compare = comparator || DeepEqual;
+                const compare = comparator || deepEqual;
                 const ignoreUndefined = options.ignoreUndefined;
 
                 for (let i = 0; i < value.length; ++i) {
-                    const item = path ? Reach(value[i], path) : value[i];
+                    const item = path ? reach(value[i], path) : value[i];
                     const records = comparator ? found.custom : found[typeof item];
-                    Assert(records, 'Failed to find unique map container for type', typeof item);
+                    assert(records, 'Failed to find unique map container for type', typeof item);
 
                     if (records instanceof Map) {
                         const entries = records.entries();
@@ -565,6 +563,30 @@ module.exports = Any.extend({
         }
     },
 
+    overrides: {
+
+        isAsync() {
+
+            if (this.$_terms.externals?.length) {
+                return true;
+            }
+
+            for (const item of this.$_terms.items) {
+                if (item.isAsync()) {
+                    return true;
+                }
+            }
+
+            for (const item of this.$_terms.ordered) {
+                if (item.isAsync()) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    },
+
     cast: {
         set: {
             from: Array.isArray,
@@ -727,7 +749,7 @@ internals.validateSingle = function (type, obj) {
     if (type.type === 'array' ||
         type._flags._arrayItems) {
 
-        Assert(!obj._flags.single, 'Cannot specify array item with single rule enabled');
+        assert(!obj._flags.single, 'Cannot specify array item with single rule enabled');
         obj.$_setFlag('_arrayItems', true, { clone: false });
     }
 };

package/lib/types/binary.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -21,7 +21,7 @@ module.exports = Any.extend({
                 try {
                     return { value: Buffer.from(value, schema._flags.encoding) };
                 }
-                catch (ignoreErr) { }
+                catch { }
             }
         }
     },
@@ -37,7 +37,7 @@ module.exports = Any.extend({
         encoding: {
             method(encoding) {
 
-                Assert(Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);
+                assert(Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);
 
                 return this.$_setFlag('encoding', encoding);
             }

package/lib/types/boolean.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -76,7 +76,7 @@ module.exports = Any.extend({
                 for (let i = 0; i < values.length; ++i) {
                     const value = values[i];
 
-                    Assert(value !== undefined, 'Cannot call truthy with undefined');
+                    assert(value !== undefined, 'Cannot call truthy with undefined');
                     obj.$_terms.truthy.add(value);
                 }
 
@@ -95,7 +95,7 @@ module.exports = Any.extend({
                 for (let i = 0; i < values.length; ++i) {
                     const value = values[i];
 
-                    Assert(value !== undefined, 'Cannot call falsy with undefined');
+                    assert(value !== undefined, 'Cannot call falsy with undefined');
                     obj.$_terms.falsy.add(value);
                 }
 

package/lib/types/date.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -78,7 +78,7 @@ module.exports = Any.extend({
         format: {
             method(format) {
 
-                Assert(['iso', 'javascript', 'unix'].includes(format), 'Unknown date format', format);
+                assert(['iso', 'javascript', 'unix'].includes(format), 'Unknown date format', format);
 
                 return this.$_setFlag('format', format);
             }
@@ -122,7 +122,7 @@ module.exports = Any.extend({
         timestamp: {
             method(type = 'javascript') {
 
-                Assert(['javascript', 'unix'].includes(type), '"type" must be one of "javascript, unix"');
+                assert(['javascript', 'unix'].includes(type), '"type" must be one of "javascript, unix"');
 
                 return this.format(type);
             }

package/lib/types/function.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Keys = require('./keys');
 
@@ -20,7 +20,7 @@ module.exports = Keys.extend({
         arity: {
             method(n) {
 
-                Assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
+                assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
 
                 return this.$_addRule({ name: 'arity', args: { n } });
             },
@@ -52,7 +52,7 @@ module.exports = Keys.extend({
         minArity: {
             method(n) {
 
-                Assert(Number.isSafeInteger(n) && n > 0, 'n must be a strict positive integer');
+                assert(Number.isSafeInteger(n) && n > 0, 'n must be a strict positive integer');
 
                 return this.$_addRule({ name: 'minArity', args: { n } });
             },
@@ -69,7 +69,7 @@ module.exports = Keys.extend({
         maxArity: {
             method(n) {
 
-                Assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
+                assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
 
                 return this.$_addRule({ name: 'maxArity', args: { n } });
             },

package/lib/types/keys.js

@@ -1,8 +1,6 @@
 'use strict';
 
-const ApplyToDefaults = require('@hapi/hoek/lib/applyToDefaults');
-const Assert = require('@hapi/hoek/lib/assert');
-const Clone = require('@hapi/hoek/lib/clone');
+const { applyToDefaults, assert, clone: Clone } = require('@hapi/hoek');
 const Topo = require('@hapi/topo');
 
 const Any = require('./any');
@@ -199,7 +197,7 @@ module.exports = Any.extend({
                     subject = Compile.ref(subject);
                 }
 
-                Assert(message === undefined || typeof message === 'string', 'Message must be a string');
+                assert(message === undefined || typeof message === 'string', 'Message must be a string');
 
                 schema = this.$_compile(schema, { appendPath: true });
 
@@ -225,7 +223,7 @@ module.exports = Any.extend({
         instance: {
             method(constructor, name) {
 
-                Assert(typeof constructor === 'function', 'constructor must be a function');
+                assert(typeof constructor === 'function', 'constructor must be a function');
 
                 name = name || constructor.name;
 
@@ -245,8 +243,8 @@ module.exports = Any.extend({
         keys: {
             method(schema) {
 
-                Assert(schema === undefined || typeof schema === 'object', 'Object schema must be a valid object');
-                Assert(!Common.isSchema(schema), 'Object schema cannot be a joi schema');
+                assert(schema === undefined || typeof schema === 'object', 'Object schema must be a valid object');
+                assert(!Common.isSchema(schema), 'Object schema cannot be a joi schema');
 
                 const obj = this.clone();
 
@@ -337,11 +335,11 @@ module.exports = Any.extend({
                     pattern = this.$_compile(pattern, { appendPath: true });
                 }
 
-                Assert(schema !== undefined, 'Invalid rule');
+                assert(schema !== undefined, 'Invalid rule');
                 Common.assertOptions(options, ['fallthrough', 'matches']);
 
                 if (isRegExp) {
-                    Assert(!pattern.flags.includes('g') && !pattern.flags.includes('y'), 'pattern should not use global or sticky mode');
+                    assert(!pattern.flags.includes('g') && !pattern.flags.includes('y'), 'pattern should not use global or sticky mode');
                 }
 
                 schema = this.$_compile(schema, { appendPath: true });
@@ -402,9 +400,9 @@ module.exports = Any.extend({
         rename: {
             method(from, to, options = {}) {
 
-                Assert(typeof from === 'string' || from instanceof RegExp, 'Rename missing the from argument');
-                Assert(typeof to === 'string' || to instanceof Template, 'Invalid rename to argument');
-                Assert(to !== from, 'Cannot rename key to same name:', from);
+                assert(typeof from === 'string' || from instanceof RegExp, 'Rename missing the from argument');
+                assert(typeof to === 'string' || to instanceof Template, 'Invalid rename to argument');
+                assert(to !== from, 'Cannot rename key to same name:', from);
 
                 Common.assertOptions(options, ['alias', 'ignoreUndefined', 'override', 'multiple']);
 
@@ -412,7 +410,7 @@ module.exports = Any.extend({
 
                 obj.$_terms.renames = obj.$_terms.renames || [];
                 for (const rename of obj.$_terms.renames) {
-                    Assert(rename.from !== from, 'Cannot rename the same key multiple times');
+                    assert(rename.from !== from, 'Cannot rename the same key multiple times');
                 }
 
                 if (to instanceof Template) {
@@ -422,7 +420,7 @@ module.exports = Any.extend({
                 obj.$_terms.renames.push({
                     from,
                     to,
-                    options: ApplyToDefaults(internals.renameDefaults, options)
+                    options: applyToDefaults(internals.renameDefaults, options)
                 });
 
                 return obj;
@@ -486,6 +484,31 @@ module.exports = Any.extend({
             }
 
             return this.$_parent('default', value, options);
+        },
+
+        isAsync() {
+
+            if (this.$_terms.externals?.length) {
+                return true;
+            }
+
+            if (this.$_terms.keys?.length) {
+                for (const key of this.$_terms.keys) {
+                    if (key.schema.isAsync()) {
+                        return true;
+                    }
+                }
+            }
+
+            if (this.$_terms.patterns?.length) {
+                for (const pattern of this.$_terms.patterns) {
+                    if (pattern.rule.isAsync()) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
         }
     },
 
@@ -589,7 +612,7 @@ internals.clone = function (value, prefs) {
 
 internals.dependency = function (schema, rel, key, peers, options) {
 
-    Assert(key === null || typeof key === 'string', rel, 'key must be a strings');
+    assert(key === null || typeof key === 'string', rel, 'key must be a strings');
 
     // Extract options from peers array
 
@@ -606,7 +629,7 @@ internals.dependency = function (schema, rel, key, peers, options) {
     const separator = Common.default(options.separator, '.');
     const paths = [];
     for (const peer of peers) {
-        Assert(typeof peer === 'string', rel, 'peers must be strings');
+        assert(typeof peer === 'string', rel, 'peers must be strings');
         paths.push(Compile.ref(peer, { separator, ancestor: 0, prefix: false }));
     }
 

package/lib/types/link.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -31,7 +31,7 @@ module.exports = Any.extend({
 
     validate(value, { schema, state, prefs }) {
 
-        Assert(schema.$_terms.link, 'Uninitialized link schema');
+        assert(schema.$_terms.link, 'Uninitialized link schema');
 
         const linked = internals.generate(schema, value, state, prefs);
         const ref = schema.$_terms.link[0].ref;
@@ -48,12 +48,12 @@ module.exports = Any.extend({
         ref: {
             method(ref) {
 
-                Assert(!this.$_terms.link, 'Cannot reinitialize schema');
+                assert(!this.$_terms.link, 'Cannot reinitialize schema');
 
                 ref = Compile.ref(ref);
 
-                Assert(ref.type === 'value' || ref.type === 'local', 'Invalid reference type:', ref.type);
-                Assert(ref.type === 'local' || ref.ancestor === 'root' || ref.ancestor > 0, 'Link cannot reference itself');
+                assert(ref.type === 'value' || ref.type === 'local', 'Invalid reference type:', ref.type);
+                assert(ref.type === 'local' || ref.ancestor === 'root' || ref.ancestor > 0, 'Link cannot reference itself');
 
                 const obj = this.clone();
                 obj.$_terms.link = [{ ref }];
@@ -73,9 +73,9 @@ module.exports = Any.extend({
 
         concat(source) {
 
-            Assert(this.$_terms.link, 'Uninitialized link schema');
-            Assert(Common.isSchema(source), 'Invalid schema object');
-            Assert(source.type !== 'link', 'Cannot merge type link with another link');
+            assert(this.$_terms.link, 'Uninitialized link schema');
+            assert(Common.isSchema(source), 'Invalid schema object');
+            assert(source.type !== 'link', 'Cannot merge type link with another link');
 
             const obj = this.clone();
 
@@ -92,7 +92,7 @@ module.exports = Any.extend({
 
         build(obj, desc) {
 
-            Assert(desc.link, 'Invalid link description missing link');
+            assert(desc.link, 'Invalid link description missing link');
             return obj.ref(desc.link);
         }
     }
@@ -115,7 +115,7 @@ internals.generate = function (schema, value, state, prefs) {
     try {
         linked = path.length ? perspective.$_reach(path) : perspective;
     }
-    catch (ignoreErr) {
+    catch {
         internals.assert(false, 'to non-existing schema', ref, schema, state, prefs);
     }
 
@@ -164,5 +164,5 @@ internals.assert = function (condition, message, ref, schema, state, prefs) {
         return;
     }
 
-    Assert(false, `"${Errors.label(schema._flags, state, prefs)}" contains link reference "${ref.display}" ${message}`);
+    assert(false, `"${Errors.label(schema._flags, state, prefs)}" contains link reference "${ref.display}" ${message}`);
 };

package/lib/types/number.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -251,7 +251,7 @@ module.exports = Any.extend({
         precision: {
             method(limit) {
 
-                Assert(Number.isSafeInteger(limit), 'limit must be an integer');
+                assert(Number.isSafeInteger(limit), 'limit must be an integer');
 
                 return this.$_addRule({ name: 'precision', args: { limit } });
             },
@@ -271,7 +271,7 @@ module.exports = Any.extend({
         sign: {
             method(sign) {
 
-                Assert(['negative', 'positive'].includes(sign), 'Invalid sign', sign);
+                assert(['negative', 'positive'].includes(sign), 'Invalid sign', sign);
 
                 return this.$_addRule({ name: 'sign', args: { sign } });
             },
@@ -290,7 +290,7 @@ module.exports = Any.extend({
         unsafe: {
             method(enabled = true) {
 
-                Assert(typeof enabled === 'boolean', 'enabled must be a boolean');
+                assert(typeof enabled === 'boolean', 'enabled must be a boolean');
 
                 return this.$_setFlag('unsafe', enabled);
             }