Feat required config

README.md

@@ -33,6 +33,7 @@ $ npm install parameter --save
 - `constructor([options])` - new Class `Parameter` instance
   - `options.translate` - translate function
   - `options.validateRoot` - config whether to validate the passed in value must be a object.
+  - `options.defaultRequired` - config whether to require the property, default to `true`
 - `validate(rule, value)` - validate the `value` conforms to `rule`. return an array of errors if break rule.
 - `addRule(type, check)` - add custom rules.
    - `type` - rule type, required and must be string type.
@@ -50,6 +51,7 @@ var parameter = new Parameter({
     return I18n.t.apply(I18n, args);
   },
   validateRoot: true, // restrict the being validate value must be a object
+  defaultRequired: false, // default to true
 });
 
 var data = {

index.js

@@ -33,6 +33,7 @@ class Parameter {
     if (opts.validateRoot) {
       this.validateRoot = true;
     }
+    this.defaultRequired = opts.defaultRequired !== false;
   }
 
   t() {
@@ -73,7 +74,8 @@ class Parameter {
       var has = obj.hasOwnProperty(key);
 
       if (!has) {
-        if (rule.required !== false) {
+        var required = rule.hasOwnProperty('required') ? rule.required : this.defaultRequired;
+        if (required) {
           errors.push({
             message: this.t('required'),
             field: key,

test/index.test.js

@@ -8,23 +8,29 @@ var parameter = new Parameter();
 var parameterWithRootValidate = new Parameter({
   validateRoot: true,
 });
+var parameterWithDefaultNotRequiredValidate = new Parameter({
+  defaultRequired: false,
+});
+var parameterWithDefaultRequiredValidate = new Parameter({
+  defaultRequired: true,
+});
 
 describe('parameter', function () {
   describe('required', function () {
     it('should required work fine', function () {
-      var value = {int: 1};
+      var value = {};
       var rule = {int: {type: 'int', required: true}};
-      parameter.validate(rule, {})[0].should.eql({
+      parameter.validate(rule, value)[0].should.eql({
         code: 'missing_field',
         field: 'int',
         message: 'required'
       });
     });
 
     it('should not required work fine', function () {
-      var value = {int: 1};
+      var value = {};
       var rule = {int: {type: 'int', required: false}};
-      should.not.exist(parameter.validate(rule, {}));
+      should.not.exist(parameter.validate(rule, value));
     });
 
     it('should not required check ok', function () {
@@ -727,3 +733,39 @@ describe('validate with option.validateRoot', function () {
     parameterWithRootValidate.validate(rule, value)[0].message.should.equal('the validated value should be a object');;
   });
 });
+
+
+describe('validate with option.defaultNotRequired', function () {
+  it('should not required work fine', function () {
+    var value = {};
+    var rule = {int: {type: 'int'}};
+    should.not.exist(parameterWithDefaultNotRequiredValidate.validate(rule, value));
+  });
+
+  it('should required check ok', function () {
+    var value = {int: 1.1};
+    var rule = {int: {type: 'int'}};
+    parameterWithDefaultRequiredValidate.validate(rule, value)[0].should.eql({
+      code: 'invalid',
+      field: 'int',
+      message: 'should be an integer'
+    });
+  });
+
+  it('should required check ok', function () {
+    var value = {int: 1.1};
+    var rule = {int: {type: 'int', required: true}};
+    parameterWithDefaultNotRequiredValidate.validate(rule, value)[0].should.eql({
+      code: 'invalid',
+      field: 'int',
+      message: 'should be an integer'
+    });
+  });
+
+  it('should not required work fine', function () {
+    var value = {};
+    var rule = {int: {type: 'int', required: false}};
+    should.not.exist(parameterWithDefaultRequiredValidate.validate(rule, value));
+  });
+
+});