joi 17.13.2 → 18.0.0

package/lib/compile.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const Assert = require('@hapi/hoek/lib/assert');
+const { assert } = require('@hapi/hoek');
 
 const Common = require('./common');
 const Ref = require('./ref');
@@ -30,10 +30,10 @@ exports.schema = function (Joi, config, options = {}) {
 
 internals.schema = function (Joi, config, options) {
 
-    Assert(config !== undefined, 'Invalid undefined schema');
+    assert(config !== undefined, 'Invalid undefined schema');
 
     if (Array.isArray(config)) {
-        Assert(config.length, 'Invalid empty array schema');
+        assert(config.length, 'Invalid empty array schema');
 
         if (config.length === 1) {
             config = config[0];
@@ -57,7 +57,7 @@ internals.schema = function (Joi, config, options) {
         return Joi.custom(config);
     }
 
-    Assert(typeof config === 'object', 'Invalid schema content:', typeof config);
+    assert(typeof config === 'object', 'Invalid schema content:', typeof config);
 
     if (Common.isResolvable(config)) {
         return valid(Joi, config);
@@ -85,7 +85,7 @@ internals.schema = function (Joi, config, options) {
         return valid(Joi.date(), config);
     }
 
-    Assert(Object.getPrototypeOf(config) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
+    assert(Object.getPrototypeOf(config) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
 
     return Joi.object().keys(config);
 };
@@ -105,7 +105,7 @@ exports.compile = function (root, schema, options = {}) {
 
     const any = schema && schema[Common.symbols.any];
     if (any) {
-        Assert(options.legacy || any.version === Common.version, 'Cannot mix different versions of joi schemas:', any.version, Common.version);
+        assert(options.legacy || any.version === Common.version, 'Cannot mix different versions of joi schemas:', any.version, Common.version);
         return schema;
     }
 
@@ -150,7 +150,7 @@ internals.walk = function (schema) {
         return { root: schema[any.root], compile: any.compile };
     }
 
-    Assert(Object.getPrototypeOf(schema) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
+    assert(Object.getPrototypeOf(schema) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
 
     for (const key in schema) {
         const compiler = internals.walk(schema[key]);
@@ -172,7 +172,7 @@ internals.simple = function (value) {
 exports.when = function (schema, condition, options) {
 
     if (options === undefined) {
-        Assert(condition && typeof condition === 'object', 'Missing options');
+        assert(condition && typeof condition === 'object', 'Missing options');
 
         options = condition;
         condition = Ref.create('.');
@@ -187,17 +187,17 @@ exports.when = function (schema, condition, options) {
     // Schema condition
 
     if (Common.isSchema(condition)) {
-        Assert(options.is === undefined, '"is" can not be used with a schema condition');
-        Assert(options.not === undefined, '"not" can not be used with a schema condition');
-        Assert(options.switch === undefined, '"switch" can not be used with a schema condition');
+        assert(options.is === undefined, '"is" can not be used with a schema condition');
+        assert(options.not === undefined, '"not" can not be used with a schema condition');
+        assert(options.switch === undefined, '"switch" can not be used with a schema condition');
 
         return internals.condition(schema, { is: condition, then: options.then, otherwise: options.otherwise, break: options.break });
     }
 
     // Single condition
 
-    Assert(Ref.isRef(condition) || typeof condition === 'string', 'Invalid condition:', condition);
-    Assert(options.not === undefined || options.is === undefined, 'Cannot combine "is" with "not"');
+    assert(Ref.isRef(condition) || typeof condition === 'string', 'Invalid condition:', condition);
+    assert(options.not === undefined || options.is === undefined, 'Cannot combine "is" with "not"');
 
     if (options.switch === undefined) {
         let rule = options;
@@ -206,8 +206,8 @@ exports.when = function (schema, condition, options) {
         }
 
         let is = rule.is !== undefined ? schema.$_compile(rule.is) : schema.$_root.invalid(null, false, 0, '').required();
-        Assert(rule.then !== undefined || rule.otherwise !== undefined, 'options must have at least one of "then", "otherwise", or "switch"');
-        Assert(rule.break === undefined || rule.then === undefined || rule.otherwise === undefined, 'Cannot specify then, otherwise, and break all together');
+        assert(rule.then !== undefined || rule.otherwise !== undefined, 'options must have at least one of "then", "otherwise", or "switch"');
+        assert(rule.break === undefined || rule.then === undefined || rule.otherwise === undefined, 'Cannot specify then, otherwise, and break all together');
 
         if (options.is !== undefined &&
             !Ref.isRef(options.is) &&
@@ -221,10 +221,10 @@ exports.when = function (schema, condition, options) {
 
     // Switch statement
 
-    Assert(Array.isArray(options.switch), '"switch" must be an array');
-    Assert(options.is === undefined, 'Cannot combine "switch" with "is"');
-    Assert(options.not === undefined, 'Cannot combine "switch" with "not"');
-    Assert(options.then === undefined, 'Cannot combine "switch" with "then"');
+    assert(Array.isArray(options.switch), '"switch" must be an array');
+    assert(options.is === undefined, 'Cannot combine "switch" with "is"');
+    assert(options.not === undefined, 'Cannot combine "switch" with "not"');
+    assert(options.then === undefined, 'Cannot combine "switch" with "then"');
 
     const rule = {
         ref: exports.ref(condition),
@@ -238,8 +238,8 @@ exports.when = function (schema, condition, options) {
 
         Common.assertOptions(test, last ? ['is', 'then', 'otherwise'] : ['is', 'then']);
 
-        Assert(test.is !== undefined, 'Switch statement missing "is"');
-        Assert(test.then !== undefined, 'Switch statement missing "then"');
+        assert(test.is !== undefined, 'Switch statement missing "is"');
+        assert(test.then !== undefined, 'Switch statement missing "then"');
 
         const item = {
             is: schema.$_compile(test.is),
@@ -253,10 +253,10 @@ exports.when = function (schema, condition, options) {
         }
 
         if (last) {
-            Assert(options.otherwise === undefined || test.otherwise === undefined, 'Cannot specify "otherwise" inside and outside a "switch"');
+            assert(options.otherwise === undefined || test.otherwise === undefined, 'Cannot specify "otherwise" inside and outside a "switch"');
             const otherwise = options.otherwise !== undefined ? options.otherwise : test.otherwise;
             if (otherwise !== undefined) {
-                Assert(rule.break === undefined, 'Cannot specify both otherwise and break');
+                assert(rule.break === undefined, 'Cannot specify both otherwise and break');
                 item.otherwise = schema.$_compile(otherwise);
             }
         }

package/lib/extend.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');
 const Messages = require('./messages');
@@ -13,7 +12,7 @@ const internals = {};
 exports.type = function (from, options) {
 
     const base = Object.getPrototypeOf(from);
-    const prototype = Clone(base);
+    const prototype = clone(base);
     const schema = from._assign(Object.create(prototype));
     const def = Object.assign({}, options);                                 // Shallow cloned
     delete def.base;
@@ -38,7 +37,7 @@ exports.type = function (from, options) {
     if (def.terms) {
         for (const name in def.terms) {                                     // Only apply own terms
             const term = def.terms[name];
-            Assert(schema.$_terms[name] === undefined, 'Invalid term override for', def.type, name);
+            assert(schema.$_terms[name] === undefined, 'Invalid term override for', def.type, name);
             schema.$_terms[name] = term.init;
             terms[name] = term;
         }
@@ -82,7 +81,7 @@ exports.type = function (from, options) {
     if (def.rules) {
         for (const name in def.rules) {
             const rule = def.rules[name];
-            Assert(typeof rule === 'object', 'Invalid rule definition for', def.type, name);
+            assert(typeof rule === 'object', 'Invalid rule definition for', def.type, name);
 
             let method = rule.method;
             if (method === undefined) {
@@ -93,11 +92,11 @@ exports.type = function (from, options) {
             }
 
             if (method) {
-                Assert(!prototype[name], 'Rule conflict in', def.type, name);
+                assert(!prototype[name], 'Rule conflict in', def.type, name);
                 prototype[name] = method;
             }
 
-            Assert(!rules[name], 'Rule conflict in', def.type, name);
+            assert(!rules[name], 'Rule conflict in', def.type, name);
             rules[name] = rule;
 
             if (rule.alias) {
@@ -115,7 +114,7 @@ exports.type = function (from, options) {
                         arg = { name: arg };
                     }
 
-                    Assert(!rule.argsByName.has(arg.name), 'Duplicated argument name', arg.name);
+                    assert(!rule.argsByName.has(arg.name), 'Duplicated argument name', arg.name);
 
                     if (Common.isSchema(arg.assert)) {
                         arg.assert = arg.assert.strict().label(arg.name);
@@ -135,10 +134,10 @@ exports.type = function (from, options) {
     const modifiers = Object.assign({}, parent.modifiers);
     if (def.modifiers) {
         for (const name in def.modifiers) {
-            Assert(!prototype[name], 'Rule conflict in', def.type, name);
+            assert(!prototype[name], 'Rule conflict in', def.type, name);
 
             const modifier = def.modifiers[name];
-            Assert(typeof modifier === 'function', 'Invalid modifier definition for', def.type, name);
+            assert(typeof modifier === 'function', 'Invalid modifier definition for', def.type, name);
 
             const method = function (arg) {
 
@@ -158,7 +157,7 @@ exports.type = function (from, options) {
         prototype._super = base;
         schema.$_super = {};                                                            // Backwards compatibility
         for (const override in def.overrides) {
-            Assert(base[override], 'Cannot override missing', override);
+            assert(base[override], 'Cannot override missing', override);
             def.overrides[override][Common.symbols.parent] = base[override];
             schema.$_super[override] = base[override].bind(schema);                     // Backwards compatibility
         }

package/lib/index.d.ts

@@ -8,6 +8,7 @@
 // TypeScript Version: 2.8
 
 // TODO express type of Schema in a type-parameter (.default, .valid, .example etc)
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 
 declare namespace Joi {
     type Types =
@@ -290,6 +291,12 @@ declare namespace Joi {
          * @default true
          */
         allowUnicode?: boolean;
+        /**
+         * If `true`, underscores (`_`) are allowed in the domain name
+         *
+         * @default false
+         */
+        allowUnderscore?: boolean;
         /**
          * if `true`, ignore invalid email length errors.
          *
@@ -341,7 +348,12 @@ declare namespace Joi {
          * @default true
          */
         allowUnicode?: boolean;
-
+        /**
+         * If `true`, underscores (`_`) are allowed in the domain name
+         *
+         * @default false
+         */
+        allowUnderscore?: boolean;
         /**
          * Options for TLD (top level domain) validation. By default, the TLD must be a valid name listed on the [IANA registry](http://data.iana.org/TLD/tlds-alpha-by-domain.txt)
          *
@@ -395,6 +407,14 @@ declare namespace Joi {
     interface GuidOptions {
         version?: GuidVersions[] | GuidVersions;
         separator?: boolean | '-' | ':';
+        /**
+         * Defines the allowed or required GUID wrapper characters where:
+         * - `undefined` - (default) the GUID can be optionally wrapped with `{}`, `[]`, or `()`. The opening and closing characters must be a matching pair.
+         * - `true` - the GUID must be wrapped with `{}`, `[]`, or `()`. The opening and closing characters must be a matching pair.
+         * - `false` - wrapper characters are not allowed.
+         * - `'['`, `'{'`, or `'('` - a specific wrapper is required (e.g., if `wrapper` is `'['`, the GUID must be enclosed in square brackets).
+         */
+        wrapper?: true | false | '[' | '{' | '(' | undefined;
     }
 
     interface UriOptions {
@@ -428,7 +448,7 @@ declare namespace Joi {
         domain?: DomainOptions;
         /**
          * Encode URI before validation.
-         * 
+         *
          * @default false
          */
         encodeUri?: boolean;
@@ -471,7 +491,7 @@ declare namespace Joi {
         otherwise: SchemaLike;
     }
 
-    interface WhenOptions {
+    interface WhenOptions<ThenSchema = any, OtherwiseSchema = any> {
         /**
          * the required condition joi type.
          */
@@ -486,12 +506,12 @@ declare namespace Joi {
         /**
          * the alternative schema type if the condition is true. Required if otherwise or switch are missing.
          */
-        then?: SchemaLike;
+        then?: SchemaLike<ThenSchema>;
 
         /**
          * the alternative schema type if the condition is false. Required if then or switch are missing.
          */
-        otherwise?: SchemaLike;
+        otherwise?: SchemaLike<OtherwiseSchema>;
 
         /**
          * the list of cases. Required if then is missing.  Required if then or otherwise are missing.
@@ -504,15 +524,15 @@ declare namespace Joi {
         break?: boolean;
     }
 
-    interface WhenSchemaOptions {
+    interface WhenSchemaOptions<ThenSchema = any, OtherwiseSchema = any> {
         /**
          * the alternative schema type if the condition is true. Required if otherwise is missing.
          */
-        then?: SchemaLike;
+        then?: SchemaLike<ThenSchema>;
         /**
          * the alternative schema type if the condition is false. Required if then is missing.
          */
-        otherwise?: SchemaLike;
+        otherwise?: SchemaLike<OtherwiseSchema>;
     }
 
     interface Cache {
@@ -772,8 +792,13 @@ declare namespace Joi {
 
     type ExternalValidationFunction<V = any, R = V> = (value: V, helpers: ExternalHelpers<R>) => R | undefined;
 
-    type SchemaLikeWithoutArray = string | number | boolean | null | Schema | SchemaMap;
-    type SchemaLike = SchemaLikeWithoutArray | object;
+    type Primitives = string | number | boolean | bigint | symbol | null;
+
+    type SchemaLikeWithoutArray<TSchema = any> = Exclude<
+      (Primitives | Schema<TSchema> | SchemaMap<TSchema>),
+      any[]
+    >;
+    type SchemaLike<TSchema = any> = SchemaLikeWithoutArray<TSchema> | object;
 
     type NullableType<T> = undefined | null | T
 
@@ -945,7 +970,7 @@ declare namespace Joi {
         $_validate(value: any, state: State, prefs: ValidationOptions): ValidationResult;
     }
 
-    interface AnySchema<TSchema = any> extends SchemaInternals {
+    interface AnySchema<TSchema = any> extends SchemaInternals, StandardSchemaV1<TSchema> {
         /**
          * Flags of current schema.
          */
@@ -1043,8 +1068,8 @@ declare namespace Joi {
         disallow(...values: any[]): this;
 
         /**
-         * Considers anything that matches the schema to be empty (undefined).
-         * @param schema - any object or joi schema to match. An undefined schema unsets that rule.
+         * Considers anything that matches the schema to be empty (undefined). Overrides any previous calls to empty.
+         * @param schema - an object, value, or joi schema to match or an array of objects, values, and joi schemas to match. An undefined schema unsets that rule.
          */
         empty(schema?: SchemaLike): this;
 
@@ -1137,6 +1162,11 @@ declare namespace Joi {
          */
         invalid(...values: any[]): this;
 
+        /**
+         * Returns a boolean indicating whether this schema contains a rule that requires asynchronous validation.
+         */
+        isAsync(): boolean;
+
         /**
          * Same as `rule({ keep: true })`.
          *
@@ -1648,7 +1678,13 @@ declare namespace Joi {
          *
          * @param type - a joi schema object to validate each array item against.
          */
-        items(...types: SchemaLikeWithoutArray[]): this;
+        items<A>(a: SchemaLikeWithoutArray<A>): ArraySchema<A[]>;
+        items<A, B>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>): ArraySchema<(A | B)[]>;
+        items<A, B, C>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>, c: SchemaLikeWithoutArray<C>): ArraySchema<(A | B | C)[]>;
+        items<A, B, C, D>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>, c: SchemaLikeWithoutArray<C>, d: SchemaLikeWithoutArray<D>): ArraySchema<(A | B | C| D)[]>;
+        items<A, B, C, D, E>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>, c: SchemaLikeWithoutArray<C>, d: SchemaLikeWithoutArray<D>, e: SchemaLikeWithoutArray<E>): ArraySchema<(A | B | C| D | E)[]>;
+        items<A, B, C, D, E , F>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>, c: SchemaLikeWithoutArray<C>, d: SchemaLikeWithoutArray<D>, e: SchemaLikeWithoutArray<E>, f: SchemaLikeWithoutArray<F>): ArraySchema<(A | B | C| D | E |F)[]>;
+        items<TItems>(...types: SchemaLikeWithoutArray<TItems>[]): this;
 
         /**
          * Specifies the exact number of items in the array.
@@ -1922,8 +1958,8 @@ declare namespace Joi {
         /**
          * Adds a conditional alternative schema type, either based on another key value, or a schema peeking into the current value.
          */
-        conditional(ref: string | Reference, options: WhenOptions | WhenOptions[]): this;
-        conditional(ref: Schema, options: WhenSchemaOptions): this;
+        conditional<ThenSchema, OtherwiseSchema>(ref: string | Reference, options: WhenOptions | WhenOptions[]): AlternativesSchema<ThenSchema | OtherwiseSchema>;
+        conditional<ThenSchema, OtherwiseSchema>(ref: Schema, options: WhenSchemaOptions<ThenSchema, OtherwiseSchema>): AlternativesSchema<ThenSchema | OtherwiseSchema>;
 
         /**
          * Requires the validated value to match a specific set of the provided alternative.try() schemas.
@@ -1934,6 +1970,12 @@ declare namespace Joi {
         /**
          * Adds an alternative schema type for attempting to match against the validated value.
          */
+        try<A>(a: SchemaLikeWithoutArray<A>): AlternativesSchema<A>;
+        try<A, B>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>): AlternativesSchema<A | B>;
+        try<A, B, C>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>, c: SchemaLikeWithoutArray<C>): AlternativesSchema<A | B | C>;
+        try<A, B, C, D>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>, c: SchemaLikeWithoutArray<C>, d: SchemaLikeWithoutArray<D>): AlternativesSchema<A | B | C| D>;
+        try<A, B, C, D, E>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>, c: SchemaLikeWithoutArray<C>, d: SchemaLikeWithoutArray<D>, e: SchemaLikeWithoutArray<E>): AlternativesSchema<A | B | C| D | E>;
+        try<A, B, C, D, E , F>(a: SchemaLikeWithoutArray<A>, b: SchemaLikeWithoutArray<B>, c: SchemaLikeWithoutArray<C>, d: SchemaLikeWithoutArray<D>, e: SchemaLikeWithoutArray<E>, f: SchemaLikeWithoutArray<F>): AlternativesSchema<A | B | C| D | E |F>;
         try(...types: SchemaLikeWithoutArray[]): this;
     }
 
@@ -2092,12 +2134,12 @@ declare namespace Joi {
         array<TSchema = any[]>(): ArraySchema<TSchema>;
 
         /**
-         * Generates a schema object that matches a boolean data type (as well as the strings 'true', 'false', 'yes', and 'no'). Can also be called via boolean().
+         * Generates a schema object that matches a boolean data type (as well as the strings 'true' and 'false'). Can also be called via boolean().
          */
         bool<TSchema = boolean>(): BooleanSchema<TSchema>;
 
         /**
-         * Generates a schema object that matches a boolean data type (as well as the strings 'true', 'false', 'yes', and 'no'). Can also be called via bool().
+         * Generates a schema object that matches a boolean data type (as well as the strings 'true' and 'false'). Can also be called via bool().
          */
         boolean<TSchema = boolean>(): BooleanSchema<TSchema>;
 
@@ -2145,12 +2187,28 @@ declare namespace Joi {
         /**
          * Generates a type that will match one of the provided alternative schemas
          */
-        alternatives<TSchema = any>(types: SchemaLike[]): AlternativesSchema<TSchema>;
-        alternatives<TSchema = any>(...types: SchemaLike[]): AlternativesSchema<TSchema>;
+        alternatives<A,B>(params: [SchemaLike<A>,SchemaLike<B>]): AlternativesSchema<A | B>;
+        alternatives<A,B,C>(params: [SchemaLike<A>, SchemaLike<B>, SchemaLike<C>]): AlternativesSchema<A | B | C>;
+        alternatives<A,B,C,D>(params: [SchemaLike<A>, SchemaLike<B>, SchemaLike<C>,  SchemaLike<D>]): AlternativesSchema<A | B | C | D>;
+        alternatives<A,B,C,D, E>(params: [SchemaLike<A>,SchemaLike<B>, SchemaLike<C>,  SchemaLike<D>,  SchemaLike<E>]): AlternativesSchema<A | B | C | D|E>;
+        alternatives<A,B>(a: SchemaLike<A>,b: SchemaLike<B>): AlternativesSchema<A | B>;
+        alternatives<A,B,C>(a: SchemaLike<A>,b: SchemaLike<B>, c:SchemaLike<C>): AlternativesSchema<A | B | C>;
+        alternatives<A,B,C,D>(a: SchemaLike<A>,b: SchemaLike<B>, c:SchemaLike<C>, d: SchemaLike<D>): AlternativesSchema<A | B | C | D>;
+        alternatives<A,B,C,D, E>(a: SchemaLike<A>,b: SchemaLike<B>, c:SchemaLike<C>, d: SchemaLike<D>, e: SchemaLike<E>): AlternativesSchema<A | B | C | D|E>;
+        alternatives<TSchema = any>(types: SchemaLike<TSchema>[]): AlternativesSchema<TSchema>;
+        alternatives<TSchema = any>(...types: SchemaLike<TSchema>[]): AlternativesSchema<TSchema>;
 
         /**
          * Alias for `alternatives`
          */
+        alt<A,B>(params: [SchemaLike<A>,SchemaLike<B>]): AlternativesSchema<A | B>;
+        alt<A,B,C>(params: [SchemaLike<A>, SchemaLike<B>, SchemaLike<C>]): AlternativesSchema<A | B | C>;
+        alt<A,B,C,D>(params: [SchemaLike<A>, SchemaLike<B>, SchemaLike<C>,  SchemaLike<D>]): AlternativesSchema<A | B | C | D>;
+        alt<A,B,C,D, E>(params: [SchemaLike<A>,SchemaLike<B>, SchemaLike<C>,  SchemaLike<D>,  SchemaLike<E>]): AlternativesSchema<A | B | C | D|E>;
+        alt<A,B>(a: SchemaLike<A>,b: SchemaLike<B>): AlternativesSchema<A | B>;
+        alt<A,B,C>(a: SchemaLike<A>,b: SchemaLike<B>, c:SchemaLike<C>): AlternativesSchema<A | B | C>;
+        alt<A,B,C,D>(a: SchemaLike<A>,b: SchemaLike<B>, c:SchemaLike<C>, d: SchemaLike<D>): AlternativesSchema<A | B | C | D>;
+        alt<A,B,C,D, E>(a: SchemaLike<A>,b: SchemaLike<B>, c:SchemaLike<C>, d: SchemaLike<D>, e: SchemaLike<E>): AlternativesSchema<A | B | C | D|E>;
         alt<TSchema = any>(types: SchemaLike[]): AlternativesSchema<TSchema>;
         alt<TSchema = any>(...types: SchemaLike[]): AlternativesSchema<TSchema>;
 

package/lib/index.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 Cache = require('./cache');
 const Common = require('./common');
@@ -54,7 +53,7 @@ internals.root = function () {
     for (const type of root._types) {
         root[type] = function (...args) {
 
-            Assert(!args.length || ['alternatives', 'link', 'object'].includes(type), 'The', type, 'type does not allow arguments');
+            assert(!args.length || ['alternatives', 'link', 'object'].includes(type), 'The', type, 'type does not allow arguments');
             return internals.generate(this, internals.types[type], args);
         };
     }
@@ -109,7 +108,7 @@ internals.methods = {
 
     build(desc) {
 
-        Assert(typeof Manifest.build === 'function', 'Manifest functionality disabled');
+        assert(typeof Manifest.build === 'function', 'Manifest functionality disabled');
         return Manifest.build(this, desc);
     },
 
@@ -125,12 +124,12 @@ internals.methods = {
 
     defaults(modifier) {
 
-        Assert(typeof modifier === 'function', 'modifier must be a function');
+        assert(typeof modifier === 'function', 'modifier must be a function');
 
         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');
+            assert(Common.isSchema(schema), 'modifier must return a valid schema object');
 
             joi[type] = function (...args) {
 
@@ -152,7 +151,7 @@ internals.methods = {
 
         Schemas = Schemas || require('./schemas');
 
-        Assert(extensions.length, 'You need to provide at least one extension');
+        assert(extensions.length, 'You need to provide at least one extension');
         this.assert(extensions, Schemas.extensions);
 
         const joi = Object.assign({}, this);
@@ -167,7 +166,7 @@ internals.methods = {
 
             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);
+                assert(joi[item.type] === undefined || joi._types.has(item.type), 'Cannot override name', item.type);
 
                 const base = item.base || this.any();
                 const schema = Extend.type(base, item);
@@ -236,7 +235,7 @@ internals.assert = function (value, schema, annotate, args /* [message], [option
     const display = annotate && typeof error.annotate === 'function' ? error.annotate() : error.message;
 
     if (error instanceof Errors.ValidationError === false) {
-        error = Clone(error);
+        error = clone(error);
     }
 
     error.message = message ? `${message} ${display}` : display;
@@ -246,7 +245,7 @@ internals.assert = function (value, schema, annotate, args /* [message], [option
 
 internals.generate = function (root, schema, args) {
 
-    Assert(root, 'Must be invoked on a Joi instance.');
+    assert(root, 'Must be invoked on a Joi instance.');
 
     schema.$_root = root;
 

package/lib/manifest.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');
 const Messages = require('./messages');
@@ -41,7 +40,7 @@ exports.describe = function (schema) {
     // Preferences
 
     if (schema._preferences) {
-        desc.preferences = Clone(schema._preferences, { shallow: ['messages'] });
+        desc.preferences = clone(schema._preferences, { shallow: ['messages'] });
         delete desc.preferences[Common.symbols.prefs];
         if (desc.preferences.messages) {
             desc.preferences.messages = Messages.decompile(desc.preferences.messages);
@@ -106,7 +105,7 @@ exports.describe = function (schema) {
             continue;
         }
 
-        Assert(!desc[term], 'Cannot describe schema due to internal name conflict with', term);
+        assert(!desc[term], 'Cannot describe schema due to internal name conflict with', term);
 
         const items = schema.$_terms[term];
         if (!items) {
@@ -126,7 +125,7 @@ exports.describe = function (schema) {
             continue;
         }
 
-        Assert(def.terms[term], 'Term', term, 'missing configuration');
+        assert(def.terms[term], 'Term', term, 'missing configuration');
         const manifest = def.terms[term].manifest;
         const mapped = typeof manifest === 'object';
         if (!items.length &&
@@ -155,7 +154,7 @@ exports.describe = function (schema) {
         // Single
 
         if (manifest === 'single') {
-            Assert(normalized.length === 1, 'Term', term, 'contains more than one item');
+            assert(normalized.length === 1, 'Term', term, 'contains more than one item');
             desc[term] = normalized[0];
             continue;
         }
@@ -187,7 +186,7 @@ internals.describe = function (item, options = {}) {
     }
 
     if (options.assign === 'options') {
-        return Clone(item);
+        return clone(item);
     }
 
     if (Buffer && Buffer.isBuffer(item)) {                          // $lab:coverage:ignore$
@@ -264,7 +263,7 @@ internals.Builder = class {
         if (desc.flags) {
             for (const flag in desc.flags) {
                 const setter = def.flags[flag] && def.flags[flag].setter || flag;
-                Assert(typeof schema[setter] === 'function', 'Invalid flag', flag, 'for type', desc.type);
+                assert(typeof schema[setter] === 'function', 'Invalid flag', flag, 'for type', desc.type);
                 schema = schema[setter](this.build(desc.flags[flag]));
             }
         }
@@ -289,7 +288,7 @@ internals.Builder = class {
 
         if (desc.rules) {
             for (const rule of desc.rules) {
-                Assert(typeof schema[rule.name] === 'function', 'Invalid rule', rule.name, 'for type', desc.type);
+                assert(typeof schema[rule.name] === 'function', 'Invalid rule', rule.name, 'for type', desc.type);
 
                 const args = [];
                 if (rule.args) {
@@ -301,13 +300,13 @@ internals.Builder = class {
                     const keys = Object.keys(built);
                     const definition = def.rules[rule.name].args;
                     if (definition) {
-                        Assert(keys.length <= definition.length, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to', definition.length, ', found', keys.length, ')');
+                        assert(keys.length <= definition.length, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to', definition.length, ', found', keys.length, ')');
                         for (const { name } of definition) {
                             args.push(built[name]);
                         }
                     }
                     else {
-                        Assert(keys.length === 1, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to 1, found', keys.length, ')');
+                        assert(keys.length === 1, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to 1, found', keys.length, ')');
                         args.push(built[keys[0]]);
                     }
                 }
@@ -339,7 +338,7 @@ internals.Builder = class {
                 continue;
             }
 
-            Assert(def.terms[key], 'Term', key, 'missing configuration');
+            assert(def.terms[key], 'Term', key, 'missing configuration');
             const manifest = def.terms[key].manifest;
 
             if (manifest === 'schema') {
@@ -394,7 +393,7 @@ internals.Builder = class {
         }
 
         if (options.assign === 'options') {
-            return Clone(desc);
+            return clone(desc);
         }
 
         if (options.assign === 'regex') {
@@ -411,7 +410,7 @@ internals.Builder = class {
 
         if (Object.keys(desc).length === 1) {
             if (desc.buffer) {
-                Assert(Buffer, 'Buffers are not supported');
+                assert(Buffer, 'Buffers are not supported');
                 return Buffer && Buffer.from(desc.buffer, 'binary');                    // $lab:coverage:ignore$
             }
 
@@ -432,12 +431,12 @@ internals.Builder = class {
             }
 
             if (desc.special) {
-                Assert(['deep'].includes(desc.special), 'Unknown special value', desc.special);
+                assert(['deep'].includes(desc.special), 'Unknown special value', desc.special);
                 return Common.symbols.deepDefault;
             }
 
             if (desc.value) {
-                return Clone(desc.value);
+                return clone(desc.value);
             }
         }