fix: support object value in within, notIn and unique validators

src/standard-validators.js

@@ -286,14 +286,14 @@ export function config (validation) {
 
   // {validate: 'within', items: [ ... ], caseInsensitive: true}
   validation.addValidator("within", [
-    {if: "!$caseInsensitive", validate: "isTrue", value: "_.includes($items, $value)", message: "must be one of ${_.join($items, ', ')}"},
-    {if: "$caseInsensitive", validate: "isTrue", value: "_.includes(_.map($items, _.toLower), _.toLower($value))", message: "must be one of ${_.join($items, ', ')}"},
+    {if: "!$caseInsensitive", validate: "isTrue", value: "_.differenceWith([$value], $items, _.isEqual).length === 0", message: "must be one of ${_.join(_.map($items, JSON.stringify), ', ')}"},
+    {if: "$caseInsensitive", validate: "isTrue", value: "_.includes(_.map($items, _.toLower), _.toLower($value))", message: "must be one of ${_.join(_.map($items, JSON.stringify), ', ')}"},
   ]);
 
   // {validate: 'notIn', items: [ ... ], caseInsensitive: true}
   validation.addValidator("notIn", [
-    {if: "!$caseInsensitive", validate: "isFalse", value: "_.includes($items, $value)", message: "must not be one of ${_.join($items, ', ')}"},
-    {if: "$caseInsensitive", validate: "isFalse", value: "_.includes(_.map($items, _.toLower), _.toLower($value))", message: "must not be one of ${_.join($items, ', ')}"},
+    {if: "!$caseInsensitive", validate: "isFalse", value: "_.differenceWith([$value], $items, _.isEqual).length === 0", message: "must not be one of ${_.join(_.map($items, JSON.stringify), ', ')}"},
+    {if: "$caseInsensitive", validate: "isFalse", value: "_.includes(_.map($items, _.toLower), _.toLower($value))", message: "must not be one of ${_.join(_.map($items, JSON.stringify), ', ')}"},
   ]);
 
   // {validate: 'contain', item: obj, /* or items: [...] */}

src/validation.js

@@ -262,5 +262,6 @@ Validation.addValidator = addValidator;
 config(Validation);
 // Add lodash to helper by default
 Validation.addHelper('_', _);
+Validation.addHelper('JSON', JSON);
 
 export default Validation;

test/standard-transformers-and-validators/unique.spec.js

@@ -52,12 +52,12 @@ test('unique: tests unique across neighbours on primitive value', t => {
   t.end();
 });
 
-test('unique: works behind nested rule', t => {
+test('unique: works behind nested rule, works with object value', t => {
   let rule = {
     meta: {
       customers: {
         foreach: {
-          details: {name: ["mandatory", "unique"]}
+          details: {name: ["mandatory", "unique"], ref: "unique"}
         }
       }
     }
@@ -66,19 +66,19 @@ test('unique: works behind nested rule', t => {
   t.deepEqual(v.validate({
     meta: {
       customers: [
-        {details: {name: 'Bob'}},
-        {details: {name: 'Ali'}},
-        {details: {name: 'Bob'}},
-        {details: {name: ' '}},
-        {details: {name: 'Cloc'}}
+        {details: {name: 'Bob', ref: {id: 1}}},
+        {details: {name: 'Ali', ref: {id: 2}}},
+        {details: {name: 'Bob', ref: {id: 3}}},
+        {details: {name: ' ', ref: {id: 3}}},
+        {details: {name: 'Cloc', ref: {id: 4}}}
       ]
     }
   }, rule), {
     meta: {
       customers: {
         '0': {details: {name: ['must be unique']}},
-        '2': {details: {name: ['must be unique']}},
-        '3': {details: {name: ['must not be empty']}}
+        '2': {details: {name: ['must be unique'], ref: ['must be unique']}},
+        '3': {details: {name: ['must not be empty'], ref: ['must be unique']}},
       }
     }
   });

test/standard-transformers-and-validators/within.spec.js

@@ -6,41 +6,56 @@ const v = new Validation();
 
 test('within: tests wthin', t => {
   let rule = {a: {validate: "within", items:['a', 'b']}};
-  t.deepEqual(v.validate({a: 'c'}, rule), {a: ["must be one of a, b"]});
+  t.deepEqual(v.validate({a: 'c'}, rule), {a: ['must be one of "a", "b"']});
   t.equal(v.validate({a: 'b'}, rule), undefined);
-  t.deepEqual(v.validate({a: 'B'}, rule), {a: ["must be one of a, b"]});
+  t.deepEqual(v.validate({a: 'B'}, rule), {a: ['must be one of "a", "b"']});
   t.end();
 });
 
 test('within: tests wthin case insensitively', t => {
   let rule = {a: {validate: "within", items:['a', 'b'], caseInsensitive: true}};
-  t.deepEqual(v.validate({a: 'c'}, rule), {a: ["must be one of a, b"]});
+  t.deepEqual(v.validate({a: 'c'}, rule), {a: ['must be one of "a", "b"']});
   t.equal(v.validate({a: 'b'}, rule), undefined);
   t.equal(v.validate({a: 'B'}, rule), undefined);
   t.end();
 });
 
 test('within: tests wthin with runtime bind', t => {
   let rule = {a: {validate: "within", 'items.bind': "$input.split(',')", input:'a,b', caseInsensitive: true}};
-  t.deepEqual(v.validate({a: 'c'}, rule), {a: ["must be one of a, b"]});
+  t.deepEqual(v.validate({a: 'c'}, rule), {a: ['must be one of "a", "b"']});
   t.equal(v.validate({a: 'b'}, rule), undefined);
   t.equal(v.validate({a: 'B'}, rule), undefined);
   t.end();
 });
 
+test('within: tests wthin with object values', t => {
+  let rule = {a: {validate: "within", items:[{v: 'a'}, {v: 'b'}]}};
+  t.deepEqual(v.validate({a: {v: 'c'}}, rule), {a: ['must be one of {"v":"a"}, {"v":"b"}']});
+  t.equal(v.validate({a: {v: 'b'}}, rule), undefined);
+  t.deepEqual(v.validate({a: {v: 'B'}}, rule), {a: ['must be one of {"v":"a"}, {"v":"b"}']});
+  t.end();
+});
+
 test('notIn: tests not within', t => {
   let rule = {a: {validate: "notIn", items:['a', 'b']}};
   t.equal(v.validate({a: 'c'}, rule), undefined);
-  t.deepEqual(v.validate({a: 'b'}, rule), {a: ["must not be one of a, b"]});
+  t.deepEqual(v.validate({a: 'b'}, rule), {a: ['must not be one of "a", "b"']});
   t.equal(v.validate({a: 'B'}, rule),undefined);
   t.end();
 });
 
-
 test('notIn: tests not within case insensitively', t => {
   let rule = {a: {validate: "notIn", items:['a', 'b'], caseInsensitive: true}};
   t.equal(v.validate({a: 'c'}, rule), undefined);
-  t.deepEqual(v.validate({a: 'b'}, rule), {a: ["must not be one of a, b"]});
-  t.deepEqual(v.validate({a: 'B'}, rule), {a: ["must not be one of a, b"]});
+  t.deepEqual(v.validate({a: 'b'}, rule), {a: ['must not be one of "a", "b"']});
+  t.deepEqual(v.validate({a: 'B'}, rule), {a: ['must not be one of "a", "b"']});
+  t.end();
+});
+
+test('notIn: tests not within with object values', t => {
+  let rule = {a: {validate: "notIn", items:[{v: 'a'}, {v: 'b'}]}};
+  t.equal(v.validate({a: {v: 'c'}}, rule), undefined);
+  t.deepEqual(v.validate({a: {v: 'b'}}, rule), {a: ['must not be one of {"v":"a"}, {"v":"b"}']});
+  t.equal(v.validate({a: {v: 'B'}}, rule),undefined);
   t.end();
 });

test/validation.spec.js

@@ -350,7 +350,7 @@ test('Validation: user defined validator', t => {
   };
 
   t.equal(v.validate({value: 'NA'}, rule), undefined);
-  t.deepEqual(v.validate({value: 'C'}, rule), {value: ["must be one of A, B"]});
+  t.deepEqual(v.validate({value: 'C'}, rule), {value: ['must be one of "A", "B"']});
   t.end();
 });
 
@@ -366,7 +366,7 @@ test('Validation: user defined global validator', t => {
   const v = new Validation();
 
   t.equal(v.validate({value: 'NA'}, rule), undefined);
-  t.deepEqual(v.validate({value: 'C'}, rule), {value: ["must be one of A, B"]});
+  t.deepEqual(v.validate({value: 'C'}, rule), {value: ['must be one of "A", "B"']});
   t.end();
 });