joi 17.13.3 → 18.0.1

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
         }