joi 17.3.0 → 17.4.0

package/lib/types/alternatives.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const Assert = require('@hapi/hoek/lib/assert');
+const Merge = require('@hapi/hoek/lib/merge');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -44,8 +45,7 @@ module.exports = Any.extend({
         // Match all or one
 
         if (schema._flags.match) {
-            let hits = 0;
-            let matched;
+            const matched = [];
 
             for (let i = 0; i < schema.$_terms.matches.length; ++i) {
                 const item = schema.$_terms.matches[i];
@@ -54,23 +54,27 @@ module.exports = Any.extend({
 
                 const result = item.schema.$_validate(value, localState, prefs);
                 if (!result.errors) {
-                    ++hits;
-                    matched = result.value;
+                    matched.push(result.value);
                 }
                 else {
                     localState.restore();
                 }
             }
 
-            if (!hits) {
+            if (matched.length === 0) {
                 return { errors: error('alternatives.any') };
             }
 
             if (schema._flags.match === 'one') {
-                return hits === 1 ? { value: matched } : { errors: error('alternatives.one') };
+                return matched.length === 1 ? { value: matched[0] } : { errors: error('alternatives.one') };
             }
 
-            return hits === schema.$_terms.matches.length ? { value } : { errors: error('alternatives.all') };
+            if (matched.length !== schema.$_terms.matches.length) {
+                return { errors: error('alternatives.all') };
+            }
+
+            const allobj = schema.$_terms.matches.reduce((acc, v) => acc && v.schema.type === 'object', true);
+            return allobj ? { value: matched.reduce((acc, v) => Merge(acc, v, { mergeArrays: false })) } : { value: matched[matched.length - 1] };
         }
 
         // Match any

package/lib/types/array.js

@@ -342,6 +342,10 @@ module.exports = Any.extend({
 
                 if (ordereds.length) {
                     internals.fillOrderedErrors(schema, errors, ordereds, value, state, prefs);
+
+                    if (!errors.length) {
+                        internals.fillDefault(ordereds, value, state, prefs);
+                    }
                 }
 
                 return errors.length ? errors : value;
@@ -677,6 +681,33 @@ internals.fillOrderedErrors = function (schema, errors, ordereds, value, state,
 };
 
 
+internals.fillDefault = function (ordereds, value, state, prefs) {
+
+    const overrides = [];
+    let trailingUndefined = true;
+
+    for (let i = ordereds.length - 1; i >= 0; --i) {
+        const ordered = ordereds[i];
+        const ancestors = [value, ...state.ancestors];
+        const override = ordered.$_validate(undefined, state.localize(state.path, ancestors, ordered), prefs).value;
+
+        if (trailingUndefined) {
+            if (override === undefined) {
+                continue;
+            }
+
+            trailingUndefined = false;
+        }
+
+        overrides.unshift(override);
+    }
+
+    if (overrides.length) {
+        value.push(...overrides);
+    }
+};
+
+
 internals.fastSplice = function (arr, i) {
 
     let pos = i;

package/lib/types/keys.js

@@ -112,6 +112,10 @@ module.exports = Any.extend({
                         return { value, errors: result.errors };
                     }
 
+                    if (result.value !== undefined) {
+                        value[key] = result.value;
+                    }
+
                     errors.push(...result.errors);
                 }
                 else if (child.schema._flags.result === 'strip' ||
@@ -600,7 +604,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 a string or a reference');
+        Assert(typeof peer === 'string', rel, 'peers must be strings');
         paths.push(Compile.ref(peer, { separator, ancestor: 0, prefix: false }));
     }
 

package/lib/types/string.js

@@ -647,11 +647,12 @@ module.exports = Any.extend({
 
                 const match = regex.exec(value);
                 if (match) {
-                    if (domain) {
-                        const matched = match[1] || match[2];
-                        if (!Domain.isValid(matched, domain)) {
-                            return helpers.error('string.domain', { value: matched });
-                        }
+                    const matched = match[1] || match[2];
+                    if (domain &&
+                        (!options.allowRelative || matched) &&
+                        !Domain.isValid(matched, domain)) {
+
+                        return helpers.error('string.domain', { value: matched });
                     }
 
                     return value;