joi 17.1.1 → 17.4.0

package/lib/manifest.js

@@ -256,7 +256,7 @@ internals.Builder = class {
 
         // Type
 
-        let schema = this.joi[desc.type]();
+        let schema = this.joi[desc.type]()._bare();
         const def = schema._definition;
 
         // Flags

package/lib/ref.js

@@ -25,7 +25,7 @@ const internals = {
 exports.create = function (key, options = {}) {
 
     Assert(typeof key === 'string', 'Invalid reference key:', key);
-    Common.assertOptions(options, ['adjust', 'ancestor', 'in', 'iterables', 'map', 'prefix', 'separator']);
+    Common.assertOptions(options, ['adjust', 'ancestor', 'in', 'iterables', 'map', 'prefix', 'render', 'separator']);
     Assert(!options.prefix || typeof options.prefix === 'object', 'options.prefix must be of type object');
 
     const ref = Object.assign({}, internals.defaults, options);
@@ -77,7 +77,7 @@ exports.create = function (key, options = {}) {
 
 exports.in = function (key, options = {}) {
 
-    return exports.create(key, Object.assign({}, options, { in: true }));
+    return exports.create(key, { ...options, in: true });
 };
 
 
@@ -93,8 +93,8 @@ internals.Ref = class {
 
         Assert(typeof options === 'object', 'Invalid reference construction');
         Common.assertOptions(options, [
-            'adjust', 'ancestor', 'in', 'iterables', 'map', 'path', 'separator', 'type',    // Copied
-            'depth', 'key', 'root', 'display'                                               // Overridden
+            'adjust', 'ancestor', 'in', 'iterables', 'map', 'path', 'render', 'separator', 'type',  // Copied
+            'depth', 'key', 'root', 'display'                                                       // Overridden
         ]);
 
         Assert([false, undefined].includes(options.separator) || typeof options.separator === 'string' && options.separator.length === 1, 'Invalid separator');
@@ -211,8 +211,10 @@ internals.Ref = class {
             ref.map = [...this.map];
         }
 
-        for (const key of ['adjust', 'iterables']) {
-            if (this[key] !== null) {
+        for (const key of ['adjust', 'iterables', 'render']) {
+            if (this[key] !== null &&
+                this[key] !== undefined) {
+
                 ref[key] = this[key];
             }
         }

package/lib/schemas.js

@@ -17,6 +17,7 @@ internals.wrap = Joi.string()
 exports.preferences = Joi.object({
     allowUnknown: Joi.boolean(),
     abortEarly: Joi.boolean(),
+    artifacts: Joi.boolean(),
     cache: Joi.boolean(),
     context: Joi.object(),
     convert: Joi.boolean(),
@@ -89,6 +90,10 @@ exports.extension = Joi.object({
     ])
         .required(),
     args: Joi.function(),
+    cast: Joi.object().pattern(internals.nameRx, Joi.object({
+        from: Joi.function().maxArity(1).required(),
+        to: Joi.function().minArity(1).maxArity(2).required()
+    })),
     base: Joi.object().schema()
         .when('type', { is: Joi.object().regex(), then: Joi.forbidden() }),
     coerce: [
@@ -157,7 +162,8 @@ internals.desc = {
             map: Joi.array().items(Joi.array().length(2)).min(1),
             adjust: Joi.function(),
             iterables: Joi.boolean(),
-            in: Joi.boolean()
+            in: Joi.boolean(),
+            render: Joi.boolean()
         })
             .required()
     }),
@@ -244,6 +250,7 @@ exports.description = Joi.object({
     preferences: {
         allowUnknown: Joi.boolean(),
         abortEarly: Joi.boolean(),
+        artifacts: Joi.boolean(),
         cache: Joi.boolean(),
         convert: Joi.boolean(),
         dateFormat: ['date', 'iso', 'string', 'time', 'utc'],

package/lib/template.js

@@ -3,7 +3,7 @@
 const Assert = require('@hapi/hoek/lib/assert');
 const Clone = require('@hapi/hoek/lib/clone');
 const EscapeHtml = require('@hapi/hoek/lib/escapeHtml');
-const Formula = require('@hapi/formula');
+const Formula = require('@sideway/formula');
 
 const Common = require('./common');
 const Errors = require('./errors');
@@ -78,8 +78,13 @@ module.exports = exports = internals.Template = class {
                 continue;
             }
 
-            const variable = part.slice(raw ? 0 : 1, end);
-            const dynamic = this._ref(internals.decode(variable), raw);
+            let variable = part.slice(raw ? 0 : 1, end);
+            const wrapped = variable[0] === ':';
+            if (wrapped) {
+                variable = variable.slice(1);
+            }
+
+            const dynamic = this._ref(internals.decode(variable), { raw, wrapped });
             processed.push(dynamic);
             if (typeof dynamic !== 'string') {
                 refs = true;
@@ -184,11 +189,10 @@ module.exports = exports = internals.Template = class {
             }
             else {
                 const rendered = this._part(part, /* context -> [*/ value, state, prefs, local, options /*] */);
-                const string = internals.stringify(rendered, prefs, options.errors);
+                const string = internals.stringify(rendered, value, state, prefs, local, options);
                 if (string !== undefined) {
                     const result = part.raw || (options.errors && options.errors.escapeHtml) === false ? string : EscapeHtml(string);
-                    const ends = part.ref && part.ref.type === 'local' && part.ref.key === 'label' && prefs.errors.wrap.label;
-                    parts.push(internals.wrap(result, ends));
+                    parts.push(internals.wrap(result, part.wrapped && prefs.errors.wrap.label));
                 }
             }
         }
@@ -196,7 +200,7 @@ module.exports = exports = internals.Template = class {
         return parts.join('');
     }
 
-    _ref(content, raw) {
+    _ref(content, { raw, wrapped }) {
 
         const refs = [];
         const reference = (variable) => {
@@ -216,7 +220,8 @@ module.exports = exports = internals.Template = class {
 
         if (formula.single) {
             if (formula.single.type === 'reference') {
-                return { ref: refs[0], raw, refs };
+                const ref = refs[0];
+                return { ref, raw, refs, wrapped: wrapped || ref.type === 'local' && ref.key === 'label' };
             }
 
             return internals.stringify(formula.single.value);
@@ -302,10 +307,18 @@ internals.wrap = function (value, ends) {
 };
 
 
-internals.stringify = function (value, prefs, options) {
+internals.stringify = function (value, original, state, prefs, local, options) {
 
     const type = typeof value;
 
+    let skipWrap = false;
+    if (Ref.isRef(value) &&
+        value.render) {
+
+        skipWrap = value.in;
+        value = value.resolve(original, state, prefs, local, { in: value.in, ...options });
+    }
+
     if (value === null) {
         return 'null';
     }
@@ -344,7 +357,11 @@ internals.stringify = function (value, prefs, options) {
 
     let partial = '';
     for (const item of value) {
-        partial = partial + (partial.length ? ', ' : '') + internals.stringify(item, prefs, options);
+        partial = partial + (partial.length ? ', ' : '') + internals.stringify(item, original, state, prefs, local, options);
+    }
+
+    if (skipWrap) {
+        return partial;
     }
 
     return internals.wrap(partial, prefs.errors.wrap.array);

package/lib/trace.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const DeepEqual = require('@hapi/hoek/lib/deepEqual');
-const Pinpoint = require('@hapi/pinpoint');
+const Pinpoint = require('@sideway/pinpoint');
 
 const Errors = require('./errors');
 

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
@@ -183,7 +187,7 @@ module.exports = Any.extend({
 
         label(name) {
 
-            const obj = this.$_super.label(name);
+            const obj = this.$_parent('label', name);
             const each = (item, source) => (source.path[0] !== 'is' ? item.label(name) : undefined);
             return obj.$_modify({ each, ref: false });
         }

package/lib/types/any.js

@@ -167,7 +167,7 @@ module.exports = Base.extend({
         'any.failover': '{{#label}} threw an error when running failover method',
         'any.invalid': '{{#label}} contains an invalid value',
         'any.only': '{{#label}} must be {if(#valids.length == 1, "", "one of ")}{{#valids}}',
-        'any.ref': '{{#label}} {{#arg}} references "{{#ref}}" which {{#reason}}',
+        'any.ref': '{{#label}} {{#arg}} references {{:#ref}} which {{#reason}}',
         'any.required': '{{#label}} is required',
         'any.unknown': '{{#label}} is not allowed'
     }

package/lib/types/array.js

@@ -114,7 +114,7 @@ module.exports = Any.extend({
 
                 return obj.$_mutateRebuild();
             },
-            validate(value, { schema, error, state, prefs }) {
+            validate(value, { schema, error, state, prefs, errorsArray }) {
 
                 const requireds = schema.$_terms._requireds.slice();
                 const ordereds = schema.$_terms.ordered.slice();
@@ -123,7 +123,8 @@ module.exports = Any.extend({
                 const wasArray = !value[Common.symbols.arraySingle];
                 delete value[Common.symbols.arraySingle];
 
-                const errors = [];
+                const errors = errorsArray();
+
                 let il = value.length;
                 for (let i = 0; i < il; ++i) {
                     const item = value[i];
@@ -341,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;
@@ -611,7 +616,7 @@ module.exports = Any.extend({
     messages: {
         'array.base': '{{#label}} must be an array',
         'array.excludes': '{{#label}} contains an excluded value',
-        'array.hasKnown': '{{#label}} does not contain at least one required match for type "{#patternLabel}"',
+        'array.hasKnown': '{{#label}} does not contain at least one required match for type {:#patternLabel}',
         'array.hasUnknown': '{{#label}} does not contain at least one required match',
         'array.includes': '{{#label}} does not match any of the allowed types',
         'array.includesRequiredBoth': '{{#label}} does not contain {{#knownMisses}} and {{#unknownMisses}} other required value(s)',
@@ -676,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/date.js

@@ -149,10 +149,10 @@ module.exports = Any.extend({
     messages: {
         'date.base': '{{#label}} must be a valid date',
         'date.format': '{{#label}} must be in {msg("date.format." + #format) || #format} format',
-        'date.greater': '{{#label}} must be greater than "{{#limit}}"',
-        'date.less': '{{#label}} must be less than "{{#limit}}"',
-        'date.max': '{{#label}} must be less than or equal to "{{#limit}}"',
-        'date.min': '{{#label}} must be larger than or equal to "{{#limit}}"',
+        'date.greater': '{{#label}} must be greater than {{:#limit}}',
+        'date.less': '{{#label}} must be less than {{:#limit}}',
+        'date.max': '{{#label}} must be less than or equal to {{:#limit}}',
+        'date.min': '{{#label}} must be greater than or equal to {{:#limit}}',
 
         // Messages used in date.format
 

package/lib/types/keys.js

@@ -27,6 +27,7 @@ module.exports = Any.extend({
     type: '_keys',
 
     properties: {
+
         typeof: 'object'
     },
 
@@ -111,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' ||
@@ -478,7 +483,7 @@ module.exports = Any.extend({
                 value = Common.symbols.deepDefault;
             }
 
-            return this.$_super.default(value, options);
+            return this.$_parent('default', value, options);
         }
     },
 
@@ -528,22 +533,22 @@ module.exports = Any.extend({
         'object.and': '{{#label}} contains {{#presentWithLabels}} without its required peers {{#missingWithLabels}}',
         'object.assert': '{{#label}} is invalid because {if(#subject.key, `"` + #subject.key + `" failed to ` + (#message || "pass the assertion test"), #message || "the assertion failed")}',
         'object.base': '{{#label}} must be of type {{#type}}',
-        'object.instance': '{{#label}} must be an instance of "{{#type}}"',
+        'object.instance': '{{#label}} must be an instance of {{:#type}}',
         'object.length': '{{#label}} must have {{#limit}} key{if(#limit == 1, "", "s")}',
         'object.max': '{{#label}} must have less than or equal to {{#limit}} key{if(#limit == 1, "", "s")}',
         'object.min': '{{#label}} must have at least {{#limit}} key{if(#limit == 1, "", "s")}',
         'object.missing': '{{#label}} must contain at least one of {{#peersWithLabels}}',
-        'object.nand': '"{{#mainWithLabel}}" must not exist simultaneously with {{#peersWithLabels}}',
+        'object.nand': '{{:#mainWithLabel}} must not exist simultaneously with {{#peersWithLabels}}',
         'object.oxor': '{{#label}} contains a conflict between optional exclusive peers {{#peersWithLabels}}',
         'object.pattern.match': '{{#label}} keys failed to match pattern requirements',
         'object.refType': '{{#label}} must be a Joi reference',
         'object.regex': '{{#label}} must be a RegExp object',
-        'object.rename.multiple': '{{#label}} cannot rename "{{#from}}" because multiple renames are disabled and another key was already renamed to "{{#to}}"',
-        'object.rename.override': '{{#label}} cannot rename "{{#from}}" because override is disabled and target "{{#to}}" exists',
+        'object.rename.multiple': '{{#label}} cannot rename {{:#from}} because multiple renames are disabled and another key was already renamed to {{:#to}}',
+        'object.rename.override': '{{#label}} cannot rename {{:#from}} because override is disabled and target {{:#to}} exists',
         'object.schema': '{{#label}} must be a Joi schema of {{#type}} type',
         'object.unknown': '{{#label}} is not allowed',
-        'object.with': '"{{#mainWithLabel}}" missing required peer "{{#peerWithLabel}}"',
-        'object.without': '"{{#mainWithLabel}}" conflict with forbidden peer "{{#peerWithLabel}}"',
+        'object.with': '{{:#mainWithLabel}} missing required peer {{:#peerWithLabel}}',
+        'object.without': '{{:#mainWithLabel}} conflict with forbidden peer {{:#peerWithLabel}}',
         'object.xor': '{{#label}} contains a conflict between exclusive peers {{#peersWithLabels}}'
     }
 });
@@ -599,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/number.js

@@ -284,7 +284,7 @@ module.exports = Any.extend({
         'number.integer': '{{#label}} must be an integer',
         'number.less': '{{#label}} must be less than {{#limit}}',
         'number.max': '{{#label}} must be less than or equal to {{#limit}}',
-        'number.min': '{{#label}} must be larger than or equal to {{#limit}}',
+        'number.min': '{{#label}} must be greater than or equal to {{#limit}}',
         'number.multiple': '{{#label}} must be a multiple of {{#multiple}}',
         'number.negative': '{{#label}} must be a negative number',
         'number.port': '{{#label}} must be a valid port',
@@ -312,10 +312,14 @@ internals.normalizeExponent = function (str) {
 internals.normalizeDecimal = function (str) {
 
     str = str
+        // Remove leading plus signs
         .replace(/^\+/, '')
-        .replace(/\.0+$/, '')
+        // Remove trailing zeros if there is a decimal point and unecessary decimal points
+        .replace(/\.0*$/, '')
+        // Add a integer 0 if the numbers starts with a decimal point
         .replace(/^(-?)\.([^\.]*)$/, '$10.$2')
-        .replace(/^(-?)0+([1-9])/, '$1$2');
+        // Remove leading zeros
+        .replace(/^(-?)0+([0-9])/, '$1$2');
 
     if (str.includes('.') &&
         str.endsWith('0')) {

package/lib/types/string.js

@@ -1,12 +1,12 @@
 'use strict';
 
 const Assert = require('@hapi/hoek/lib/assert');
-const Domain = require('@hapi/address/lib/domain');
-const Email = require('@hapi/address/lib/email');
-const Ip = require('@hapi/address/lib/ip');
+const Domain = require('@sideway/address/lib/domain');
+const Email = require('@sideway/address/lib/email');
+const Ip = require('@sideway/address/lib/ip');
 const EscapeRegex = require('@hapi/hoek/lib/escapeRegex');
-const Tlds = require('@hapi/address/lib/tlds');
-const Uri = require('@hapi/address/lib/uri');
+const Tlds = require('@sideway/address/lib/tlds');
+const Uri = require('@sideway/address/lib/uri');
 
 const Any = require('./any');
 const Common = require('../common');
@@ -41,8 +41,8 @@ const internals = {
         uuidv4: '4',
         uuidv5: '5'
     },
+    guidSeparators: new Set([undefined, true, false, '-', ':']),
 
-    cidrPresences: ['required', 'optional', 'forbidden'],
     normalizationForms: ['NFC', 'NFD', 'NFKC', 'NFKD']
 };
 
@@ -257,7 +257,7 @@ module.exports = Any.extend({
             method(options) {
 
                 if (options) {
-                    Common.assertOptions(options, ['allowUnicode', 'minDomainSegments', 'tlds']);
+                    Common.assertOptions(options, ['allowUnicode', 'maxDomainSegments', 'minDomainSegments', 'tlds']);
                 }
 
                 const address = internals.addressOptions(options);
@@ -276,7 +276,7 @@ module.exports = Any.extend({
         email: {
             method(options = {}) {
 
-                Common.assertOptions(options, ['allowUnicode', 'ignoreLength', 'minDomainSegments', 'multiple', 'separator', 'tlds']);
+                Common.assertOptions(options, ['allowUnicode', 'ignoreLength', 'maxDomainSegments', 'minDomainSegments', 'multiple', 'separator', 'tlds']);
                 Assert(options.multiple === undefined || typeof options.multiple === 'boolean', 'multiple option must be an boolean');
 
                 const address = internals.addressOptions(options);
@@ -306,7 +306,7 @@ module.exports = Any.extend({
             alias: 'uuid',
             method(options = {}) {
 
-                Common.assertOptions(options, ['version']);
+                Common.assertOptions(options, ['version', 'separator']);
 
                 let versionNumbers = '';
 
@@ -328,7 +328,12 @@ module.exports = Any.extend({
                     }
                 }
 
-                const regex = new RegExp(`^([\\[{\\(]?)[0-9A-F]{8}([:-]?)[0-9A-F]{4}\\2?[${versionNumbers || '0-9A-F'}][0-9A-F]{3}\\2?[${versionNumbers ? '89AB' : '0-9A-F'}][0-9A-F]{3}\\2?[0-9A-F]{12}([\\]}\\)]?)$`, 'i');
+                Assert(internals.guidSeparators.has(options.separator), 'separator must be one of true, false, "-", or ":"');
+                const separator = options.separator === undefined ? '[:-]?' :
+                    options.separator === true ? '[:-]' :
+                        options.separator === false ? '[]?' : `\\${options.separator}`;
+
+                const regex = new RegExp(`^([\\[{\\(]?)[0-9A-F]{8}(${separator})[0-9A-F]{4}\\2?[${versionNumbers || '0-9A-F'}][0-9A-F]{3}\\2?[${versionNumbers ? '89AB' : '0-9A-F'}][0-9A-F]{3}\\2?[0-9A-F]{12}([\\]}\\)]?)$`, 'i');
 
                 return this.$_addRule({ name: 'guid', args: { options }, regex });
             },
@@ -627,7 +632,7 @@ module.exports = Any.extend({
                 Common.assertOptions(options, ['allowRelative', 'allowQuerySquareBrackets', 'domain', 'relativeOnly', 'scheme']);
 
                 if (options.domain) {
-                    Common.assertOptions(options.domain, ['allowUnicode', 'minDomainSegments', 'tlds']);
+                    Common.assertOptions(options.domain, ['allowUnicode', 'maxDomainSegments', 'minDomainSegments', 'tlds']);
                 }
 
                 const { regex, scheme } = Uri.regex(options);
@@ -642,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;
@@ -702,10 +708,10 @@ module.exports = Any.extend({
         'string.min': '{{#label}} length must be at least {{#limit}} characters long',
         'string.normalize': '{{#label}} must be unicode normalized in the {{#form}} form',
         'string.token': '{{#label}} must only contain alpha-numeric and underscore characters',
-        'string.pattern.base': '{{#label}} with value "{[.]}" fails to match the required pattern: {{#regex}}',
-        'string.pattern.name': '{{#label}} with value "{[.]}" fails to match the {{#name}} pattern',
-        'string.pattern.invert.base': '{{#label}} with value "{[.]}" matches the inverted pattern: {{#regex}}',
-        'string.pattern.invert.name': '{{#label}} with value "{[.]}" matches the inverted {{#name}} pattern',
+        'string.pattern.base': '{{#label}} with value {:[.]} fails to match the required pattern: {{#regex}}',
+        'string.pattern.name': '{{#label}} with value {:[.]} fails to match the {{#name}} pattern',
+        'string.pattern.invert.base': '{{#label}} with value {:[.]} matches the inverted pattern: {{#regex}}',
+        'string.pattern.invert.name': '{{#label}} with value {:[.]} matches the inverted {{#name}} pattern',
         'string.trim': '{{#label}} must not have leading or trailing whitespace',
         'string.uri': '{{#label}} must be a valid uri',
         'string.uriCustomScheme': '{{#label}} must be a valid uri with a scheme matching the {{#scheme}} pattern',
@@ -728,6 +734,11 @@ internals.addressOptions = function (options) {
     Assert(options.minDomainSegments === undefined ||
         Number.isSafeInteger(options.minDomainSegments) && options.minDomainSegments > 0, 'minDomainSegments must be a positive integer');
 
+    // maxDomainSegments
+
+    Assert(options.maxDomainSegments === undefined ||
+        Number.isSafeInteger(options.maxDomainSegments) && options.maxDomainSegments > 0, 'maxDomainSegments must be a positive integer');
+
     // tlds
 
     if (options.tlds === false) {
@@ -751,6 +762,7 @@ internals.addressOptions = function (options) {
 
         Assert(options.tlds.deny instanceof Set, 'tlds.deny must be an array, Set, or boolean');
         Assert(!options.tlds.allow, 'Cannot specify both tlds.allow and tlds.deny lists');
+        internals.validateTlds(options.tlds.deny, 'tlds.deny');
         return options;
     }
 
@@ -769,16 +781,29 @@ internals.addressOptions = function (options) {
     }
 
     Assert(options.tlds.allow instanceof Set, 'tlds.allow must be an array, Set, or boolean');
+    internals.validateTlds(options.tlds.allow, 'tlds.allow');
     return options;
 };
 
 
+internals.validateTlds = function (set, source) {
+
+    for (const tld of set) {
+        Assert(Domain.isValid(tld, { minDomainSegments: 1, maxDomainSegments: 1 }), `${source} must contain valid top level domain names`);
+    }
+};
+
+
 internals.isoDate = function (value) {
 
     if (!Common.isIsoDate(value)) {
         return null;
     }
 
+    if (/.*T.*[+-]\d\d$/.test(value)) {             // Add missing trailing zeros to timeshift
+        value += '00';
+    }
+
     const date = new Date(value);
     if (isNaN(date.getTime())) {
         return null;