joi 17.1.1 → 17.2.0

package/lib/base.js

@@ -32,6 +32,11 @@ internals.Base = class {
 
         this.$_root = null;
         this._definition = {};
+        this._reset();
+    }
+
+    _reset() {
+
         this._ids = new Modify.Ids();
         this._preferences = null;
         this._refs = new Ref.Manager();
@@ -85,6 +90,14 @@ internals.Base = class {
         return obj;
     }
 
+    artifact(id) {
+
+        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');
@@ -316,6 +329,7 @@ internals.Base = class {
 
         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();
@@ -749,6 +763,11 @@ internals.Base = class {
         return obj;
     }
 
+    $_parent(method, ...args) {
+
+        return this[method][Common.symbols.parent].call(this, ...args);
+    }
+
     $_validate(value, state, prefs) {
 
         return Validator.validate(value, this, state, prefs);
@@ -780,6 +799,8 @@ internals.Base = class {
             target.$_terms[key] = this.$_terms[key] ? this.$_terms[key].slice() : null;
         }
 
+        // Backwards compatibility
+
         target.$_super = {};
         for (const override in this.$_super) {
             target.$_super[override] = this._super[override].bind(target);
@@ -788,6 +809,20 @@ internals.Base = class {
         return target;
     }
 
+    _bare() {
+
+        const obj = this.clone();
+        obj._reset();
+
+        const terms = obj._definition.terms;
+        for (const name in terms) {
+            const term = terms[name];
+            obj.$_terms[name] = term.init;
+        }
+
+        return obj.$_mutateRebuild();
+    }
+
     _default(flag, value, options = {}) {
 
         Common.assertOptions(options, 'literal');

package/lib/common.js

@@ -20,6 +20,7 @@ exports.version = Pkg.version;
 exports.defaults = {
     abortEarly: true,
     allowUnknown: false,
+    artifacts: false,
     cache: true,
     context: null,
     convert: true,
@@ -50,12 +51,14 @@ exports.symbols = {
     any: Symbol.for('@hapi/joi/schema'),            // Used to internally identify any-based types (shared with other joi versions)
     arraySingle: Symbol('arraySingle'),
     deepDefault: Symbol('deepDefault'),
+    errors: Symbol('errors'),
     literal: Symbol('literal'),
     override: Symbol('override'),
+    parent: Symbol('parent'),
     prefs: Symbol('prefs'),
     ref: Symbol('ref'),
-    values: Symbol('values'),
-    template: Symbol('template')
+    template: Symbol('template'),
+    values: Symbol('values')
 };
 
 

package/lib/extend.js

@@ -156,10 +156,11 @@ exports.type = function (from, options) {
 
     if (def.overrides) {
         prototype._super = base;
-        schema.$_super = {};
+        schema.$_super = {};                                                            // Backwards compatibility
         for (const override in def.overrides) {
             Assert(base[override], 'Cannot override missing', override);
-            schema.$_super[override] = base[override].bind(schema);
+            def.overrides[override][Common.symbols.parent] = base[override];
+            schema.$_super[override] = base[override].bind(schema);                     // Backwards compatibility
         }
 
         Object.assign(prototype, def.overrides);