Merge pull request #2762 from perrin4869/feature/object-dependencies-…

…is-present

Add isPresent option to object dependencies

API.md

@@ -2274,6 +2274,7 @@ them are required as well where:
 - `peers` - the string key names of which if one present, all are required.
 - `options` - optional settings:
     - `separator` - overrides the default `.` hierarchy separator. Set to `false` to treat the `key` as a literal value.
+    - `isPresent` - function that overrides the default check for an empty value. Default: `(resolved) => resolved !== undefined`
 
 ```js
 const schema = Joi.object({
@@ -2394,6 +2395,7 @@ Defines a relationship between keys where not all peers can be present at the sa
 - `peers` - the key names of which if one present, the others may not all be present.
 - `options` - optional settings:
     - `separator` - overrides the default `.` hierarchy separator. Set to `false` to treat the `key` as a literal value.
+    - `isPresent` - function that overrides the default check for an empty value. Default: `(resolved) => resolved !== undefined`
 
 ```js
 const schema = Joi.object({
@@ -2411,6 +2413,7 @@ allowed) where:
 - `peers` - the key names of which at least one must appear.
 - `options` - optional settings:
     - `separator` - overrides the default `.` hierarchy separator. Set to `false` to treat the `key` as a literal value.
+    - `isPresent` - function that overrides the default check for an empty value. Default: `(resolved) => resolved !== undefined`
 
 ```js
 const schema = Joi.object({
@@ -2428,6 +2431,7 @@ required where:
 - `peers` - the exclusive key names that must not appear together but where none are required.
 - `options` - optional settings:
     - `separator` - overrides the default `.` hierarchy separator. Set to `false` to treat the `key` as a literal value.
+    - `isPresent` - function that overrides the default check for an empty value. Default: `(resolved) => resolved !== undefined`
 
 ```js
 const schema = Joi.object({
@@ -2566,6 +2570,7 @@ Requires the presence of other keys whenever the specified key is present where:
   single string value or an array of string values.
 - `options` - optional settings:
     - `separator` - overrides the default `.` hierarchy separator. Set to `false` to treat the `key` as a literal value.
+    - `isPresent` - function that overrides the default check for an empty value. Default: `(resolved) => resolved !== undefined`
 
 Note that unlike [`object.and()`](#objectandpeers-options), `with()` creates a dependency only between the `key` and each of the `peers`, not
 between the `peers` themselves.
@@ -2587,6 +2592,7 @@ Forbids the presence of other keys whenever the specified is present where:
   single string value or an array of string values.
 - `options` - optional settings:
     - `separator` - overrides the default `.` hierarchy separator. Set to `false` to treat the `key` as a literal value.
+    - `isPresent` - function that overrides the default check for an empty value. Default: `(resolved) => resolved !== undefined`
 
 ```js
 const schema = Joi.object({
@@ -2604,6 +2610,7 @@ the same time where:
 - `peers` - the exclusive key names that must not appear together but where one of them is required.
 - `options` - optional settings:
     - `separator` - overrides the default `.` hierarchy separator. Set to `false` to treat the `key` as a literal value.
+    - `isPresent` - function that overrides the default check for an empty value. Default: `(resolved) => resolved !== undefined`
 
 ```js
 const schema = Joi.object({

benchmarks/package.json

@@ -13,6 +13,7 @@
     "benchmark": "^2.1.4",
     "chalk": "^2.4.1",
     "cli-table": "^0.3.1",
-    "d3-format": "^1.3.2"
+    "d3-format": "^1.3.2",
+    "joi": "^17.6.4"
   }
 }

benchmarks/suite.js

@@ -37,6 +37,16 @@ module.exports = (Joi) => [
                 }).unknown(false).prefs({ convert: false }),
                 { id: '1', level: 'info' },
                 { id: '2', level: 'warning' }
+            ],
+            17: () => [
+                Joi.object({
+                    id: Joi.string().required(),
+                    level: Joi.string()
+                        .valid('debug', 'info', 'notice')
+                        .required()
+                }).unknown(false).prefs({ convert: false }),
+                { id: '1', level: 'info' },
+                { id: '2', level: 'warning' }
             ]
         },
         (schema, value) => schema.validate(value)
@@ -71,6 +81,31 @@ module.exports = (Joi) => [
                     .optional(),
             16: () =>
 
+                Joi.object({
+                    foo: Joi.array().items(
+                        Joi.boolean().required(),
+                        Joi.string().allow(''),
+                        Joi.symbol()
+                    ).single().sparse().required(),
+                    bar: Joi.number().min(12).max(353).default(56).positive(),
+                    baz: Joi.date().timestamp('unix'),
+                    qux: [Joi.function().minArity(12).strict(), Joi.binary().max(345)],
+                    quxx: Joi.string().ip({ version: ['ipv6'] }),
+                    quxxx: [554, 'azerty', true]
+                })
+                    .xor('foo', 'bar')
+                    .or('bar', 'baz')
+                    .pattern(/b/, Joi.when('a', {
+                        is: true,
+                        then: Joi.prefs({ messages: { 'any.required': 'oops' } })
+                    }))
+                    .meta('foo')
+                    .strip()
+                    .default(() => 'foo')
+                    .optional(),
+
+            17: () =>
+
                 Joi.object({
                     foo: Joi.array().items(
                         Joi.boolean().required(),
@@ -153,5 +188,16 @@ module.exports = (Joi) => [
                 { id: 1, level: 'info', tags: [true, false] }
             ],
         (schema, value) => schema.validate(value)
+    ],
+    [
+        'Dependency validation',
+        () => [
+            Joi.object({
+                'a': Joi.string(),
+                'b': Joi.string()
+            }),
+            { a: 'foo', b: 'bar' }
+        ],
+        (schema, value) => schema.validate(value)
     ]
 ];

lib/index.d.ts

@@ -268,6 +268,15 @@ declare namespace Joi {
         separator?: string | false;
     }
 
+    interface DependencyOptions extends HierarchySeparatorOptions {
+        /**
+         * overrides the default check for a present value.
+         *
+         * @default (resolved) => resolved !== undefined
+         */
+        isPresent?: (resolved: any) => boolean;
+    }
+
     interface EmailOptions {
         /**
          * if `true`, domains ending with a `.` character are permitted
@@ -1673,7 +1682,7 @@ declare namespace Joi {
          *
          * Optional settings must be the last argument.
          */
-        and(...peers: Array<string | HierarchySeparatorOptions>): this;
+        and(...peers: Array<string | DependencyOptions>): this;
 
         /**
          * Appends the allowed object keys. If schema is null, undefined, or {}, no changes will be applied.
@@ -1720,21 +1729,21 @@ declare namespace Joi {
          *
          * Optional settings must be the last argument.
          */
-        nand(...peers: Array<string | HierarchySeparatorOptions>): this;
+        nand(...peers: Array<string | DependencyOptions>): this;
 
         /**
          * Defines a relationship between keys where one of the peers is required (and more than one is allowed).
          *
          * Optional settings must be the last argument.
          */
-        or(...peers: Array<string | HierarchySeparatorOptions>): this;
+        or(...peers: Array<string | DependencyOptions>): this;
 
         /**
          * Defines an exclusive relationship between a set of keys where only one is allowed but none are required.
          *
          * Optional settings must be the last argument.
          */
-        oxor(...peers: Array<string | HierarchySeparatorOptions>): this;
+        oxor(...peers: Array<string | DependencyOptions>): this;
 
         /**
          * Specify validation rules for unknown keys matching a pattern.
@@ -1772,19 +1781,19 @@ declare namespace Joi {
         /**
          * Requires the presence of other keys whenever the specified key is present.
          */
-        with(key: string, peers: string | string[], options?: HierarchySeparatorOptions): this;
+        with(key: string, peers: string | string[], options?: DependencyOptions): this;
 
         /**
          * Forbids the presence of other keys whenever the specified is present.
          */
-        without(key: string, peers: string | string[], options?: HierarchySeparatorOptions): this;
+        without(key: string, peers: string | string[], options?: DependencyOptions): this;
 
         /**
          * Defines an exclusive relationship between a set of keys. one of them is required but not at the same time.
          *
          * Optional settings must be the last argument.
          */
-        xor(...peers: Array<string | HierarchySeparatorOptions>): this;
+        xor(...peers: Array<string | DependencyOptions>): this;
     }
 
     interface BinarySchema<TSchema = Buffer> extends AnySchema<TSchema> {

lib/types/keys.js

@@ -144,8 +144,10 @@ module.exports = Any.extend({
 
         if (schema.$_terms.dependencies) {
             for (const dep of schema.$_terms.dependencies) {
-                if (dep.key &&
-                    dep.key.resolve(value, state, prefs, null, { shadow: false }) === undefined) {
+                if (
+                    dep.key !== null &&
+                    internals.isPresent(dep.options)(dep.key.resolve(value, state, prefs, null, { shadow: false })) === false
+                ) {
 
                     continue;
                 }
@@ -595,7 +597,7 @@ internals.dependency = function (schema, rel, key, peers, options) {
         options = peers.length > 1 && typeof peers[peers.length - 1] === 'object' ? peers.pop() : {};
     }
 
-    Common.assertOptions(options, ['separator']);
+    Common.assertOptions(options, ['separator', 'isPresent']);
 
     peers = [].concat(peers);
 
@@ -618,7 +620,7 @@ internals.dependency = function (schema, rel, key, peers, options) {
 
     const obj = schema.clone();
     obj.$_terms.dependencies = obj.$_terms.dependencies || [];
-    obj.$_terms.dependencies.push(new internals.Dependency(rel, key, paths, peers));
+    obj.$_terms.dependencies.push(new internals.Dependency(rel, key, paths, peers, options));
     return obj;
 };
 
@@ -630,8 +632,9 @@ internals.dependencies = {
         const missing = [];
         const present = [];
         const count = dep.peers.length;
+        const isPresent = internals.isPresent(dep.options);
         for (const peer of dep.peers) {
-            if (peer.resolve(value, state, prefs, null, { shadow: false }) === undefined) {
+            if (isPresent(peer.resolve(value, state, prefs, null, { shadow: false })) === false) {
                 missing.push(peer.key);
             }
             else {
@@ -657,8 +660,9 @@ internals.dependencies = {
     nand(schema, dep, value, state, prefs) {
 
         const present = [];
+        const isPresent = internals.isPresent(dep.options);
         for (const peer of dep.peers) {
-            if (peer.resolve(value, state, prefs, null, { shadow: false }) !== undefined) {
+            if (isPresent(peer.resolve(value, state, prefs, null, { shadow: false }))) {
                 present.push(peer.key);
             }
         }
@@ -682,8 +686,9 @@ internals.dependencies = {
 
     or(schema, dep, value, state, prefs) {
 
+        const isPresent = internals.isPresent(dep.options);
         for (const peer of dep.peers) {
-            if (peer.resolve(value, state, prefs, null, { shadow: false }) !== undefined) {
+            if (isPresent(peer.resolve(value, state, prefs, null, { shadow: false }))) {
                 return;
             }
         }
@@ -700,8 +705,9 @@ internals.dependencies = {
     oxor(schema, dep, value, state, prefs) {
 
         const present = [];
+        const isPresent = internals.isPresent(dep.options);
         for (const peer of dep.peers) {
-            if (peer.resolve(value, state, prefs, null, { shadow: false }) !== undefined) {
+            if (isPresent(peer.resolve(value, state, prefs, null, { shadow: false }))) {
                 present.push(peer.key);
             }
         }
@@ -720,8 +726,9 @@ internals.dependencies = {
 
     with(schema, dep, value, state, prefs) {
 
+        const isPresent = internals.isPresent(dep.options);
         for (const peer of dep.peers) {
-            if (peer.resolve(value, state, prefs, null, { shadow: false }) === undefined) {
+            if (isPresent(peer.resolve(value, state, prefs, null, { shadow: false })) === false) {
                 return {
                     code: 'object.with',
                     context: {
@@ -737,8 +744,9 @@ internals.dependencies = {
 
     without(schema, dep, value, state, prefs) {
 
+        const isPresent = internals.isPresent(dep.options);
         for (const peer of dep.peers) {
-            if (peer.resolve(value, state, prefs, null, { shadow: false }) !== undefined) {
+            if (isPresent(peer.resolve(value, state, prefs, null, { shadow: false }))) {
                 return {
                     code: 'object.without',
                     context: {
@@ -755,8 +763,9 @@ internals.dependencies = {
     xor(schema, dep, value, state, prefs) {
 
         const present = [];
+        const isPresent = internals.isPresent(dep.options);
         for (const peer of dep.peers) {
-            if (peer.resolve(value, state, prefs, null, { shadow: false }) !== undefined) {
+            if (isPresent(peer.resolve(value, state, prefs, null, { shadow: false }))) {
                 present.push(peer.key);
             }
         }
@@ -787,6 +796,12 @@ internals.keysToLabels = function (schema, keys) {
 };
 
 
+internals.isPresent = function (options) {
+
+    return typeof options.isPresent === 'function' ? options.isPresent : (resolved) => resolved !== undefined;
+};
+
+
 internals.rename = function (schema, value, state, prefs, errors) {
 
     const renamed = {};
@@ -992,12 +1007,13 @@ internals.unknown = function (schema, value, unprocessed, errors, state, prefs)
 
 internals.Dependency = class {
 
-    constructor(rel, key, peers, paths) {
+    constructor(rel, key, peers, paths, options) {
 
         this.rel = rel;
         this.key = key;
         this.peers = peers;
         this.paths = paths;
+        this.options = options;
     }
 
     describe() {
@@ -1012,7 +1028,11 @@ internals.Dependency = class {
         }
 
         if (this.peers[0].separator !== '.') {
-            desc.options = { separator: this.peers[0].separator };
+            desc.options = { ...desc.options, separator: this.peers[0].separator };
+        }
+
+        if (this.options.isPresent) {
+            desc.options = { ...desc.options, isPresent: this.options.isPresent };
         }
 
         return desc;

test/types/object.js

@@ -2176,6 +2176,21 @@ describe('object', () => {
                 [{ a: 'test', b: Object.assign(() => { }, { c: 'test2' }) }, false, '"value" contains a conflict between optional exclusive peers [a, b.c]']
             ]);
         });
+
+        it('allows setting custom isPresent function', () => {
+
+            const schema = Joi.object({
+                'a': Joi.string().allow(null),
+                'b': Joi.string().allow(null)
+            })
+                .oxor('a', 'b', { isPresent: (value) => value !== undefined && value !== null });
+
+            Helper.validate(schema, [
+                [{ a: null, b: null }, true],
+                [{}, true],
+                [{ a: 'foo', b: 'bar' }, false, '"value" contains a conflict between optional exclusive peers [a, b]']
+            ]);
+        });
     });
 
     describe('pattern()', () => {