Backbone Validation: Nested validation: automatic validation of attributes of Backbone.Model type

[Lobon18]

Hello, Mr. Pedersen,

We are building an app with three models: PersonModel, CompanyModel, and AddressModel.

Please, see the attached "models.js" file. Each model has its own validation rules.
We are not pleasant with this:
http://thedersen.com/projects/backbone-validation/#configure-validation-rules-on-the-model

Because it forces us to repeat AddressModel's validation rules inside CompanyModel's and PersonModel's validation rules.

It would be nice if the validation mechanism would be recursive: validate a Model instance
implies validate its validation rules for simple types (String, Number, etc.) and, if an
attribute is of type Backbone.Model or Backbone.Collection, then it's validated again (recursivity is on). So, each validation rules are in its right place: each Model or each Collection has its own rules.

Could you balance to implement my suggestions?
Thanks in advance.

var PersonModel = Backbone.Model.extend({
defaults: {
name: null,//String
age: null,//Integer
email: null,//String
address: null//AddressModel
}
validation: {
name: {
required: true
},
age: {
range: [1, 80]
},
email: {
pattern: 'email'
},
address: {
required: false
}
}
});

var CompanyModel = Backbone.Model.extend({
defaults: {
name: null,//String
location: null//AddressModel
}
validation: {
name: {
required: true
},
location: {
required: true
}
}
});

var AddressModel = Backbone.Model.extend({
defaults: {
street: null,//String
zip: null//String
}
validation: {
street: {
required: true
},
zip: {
length: 4
}
}
});

[thedersen]

There is no support for nested models, and I don't expect to implement it in the nearest future. Too much other stuff going on I'm afraid..

[igchuk]

I think it would be enough to have a mathod validator for nested Models and Collections.

[baelter]

Just add custom validators:

            _.extend(Backbone.Validation.validators, {
                validModel: function (value, attr, customValue, model) {
                    if (value && !value.isValid(true)) {
                        return 'Invalid ' + attr;
                    }
                },
                validCollection: function (value, attr, customValue, model) {
                    var errors = value.map(function (entry) {
                        return entry.isValid(true);
                    });
                    if (_.indexOf(errors, false) !== -1) {
                        return 'Invalid collection of ' + attr;
                    }
                }
            });

[thedersen]

What @baelter suggests should work. Thanks

[Amsvartner]

In my project we are using a custom nested model plug, and the structure looks like this..

var Author.Model = Backbone.Model.extend({ 
       validation : {
             name : [
                { required : true, msg : "validation.Required" }
             ]
       }
});
var Book.Model = Backbone.Model.extend({
       relations : {
            author : Author.Model
       }
});

I modified the Backbone validate method @ line 238 to look like this..

 var model = this,
       validateAll = !attrs,
       opt = _.extend({}, options, setOptions),
       validatedAttrs = getValidatedAttrs(model),
       allAttrs = _.extend({}, validatedAttrs, model.attributes, attrs),
       changedAttrs = flatten(attrs || allAttrs),
       nestedModels = model.relations,
       validatedNestedModels = [],
       subResult = { isValid : true };
      // Validate nested models..
      Object.keys(nestedModels).forEach(function (key) {
                 var nestedObj = model.get(key),
                 attributes = {};
                 if (!nestedObj) {
                      console.log("We're missing a related model here, it needs to be initialized with model!");
                      return;
                  }
                 var isNestedModel = nestedObj instanceof Backbone.Model,
                      isNestedCollection = nestedObj instanceof Backbone.Collection, 
                      validation = nestedObj.validation;
                 if (isNestedModel) {
                          Object.keys(validation).forEach(function (key) {
                                    attributes[key] = nestedObj.get(key);
                          });
                
                          subResult = subResult.isValid ? validateModel(nestedObj, attributes) : subResult;
                          validatedNestedModels.push(getValidatedAttrs(nestedObj));
                }
                if (isNestedCollection) {
                                // Todo..
                }
      });
      var result = validateModel(model, allAttrs);
                        
       model._isValid = result.isValid && subResult.isValid ? true : false;
       // After validation is performed, loop through all validated attributes
       // and call the valid callbacks so the view is updated.
        _.each(validatedAttrs, function (val, attr) {
                  var invalid = result.invalidAttrs.hasOwnProperty(attr);
                  if (!invalid) {
                         opt.valid(view, attr, opt.selector);
                  }
        });
 
        _.each(validatedNestedModels, function (validatedAttrs) {
                  _.each(validatedAttrs, function (val, attr) {
                         var invalid = subResult.invalidAttrs.hasOwnProperty(attr);
                         if (!invalid) {
                                opt.valid(view, attr, opt.selector);
                          }
                   });
         });

         // After validation is performed, loop through all validated and changed attributes
         // and call the invalid callback so the view is updated.
         _.each(validatedAttrs, function (val, attr) {
                  var invalid = result.invalidAttrs.hasOwnProperty(attr),
                  changed = changedAttrs.hasOwnProperty(attr);
                  if (invalid && (changed || validateAll)) {
                         opt.invalid(view, attr, result.invalidAttrs[attr], opt.selector);
                  }
         });
                        
                       
         _.each(validatedNestedModels, function (validatedAttrs) {
                 _.each(validatedAttrs, function (val, attr) {
                      var invalid = subResult.invalidAttrs.hasOwnProperty(attr),
                      changed = changedAttrs.hasOwnProperty(attr);
                      if (invalid && (changed || validateAll)) {
                          opt.invalid(view, attr, subResult.invalidAttrs[attr], opt.selector);
                      }
                 });
         });

It's not pretty by any means (feel free to improve on), but it does validate all attributes and triggers validation messages on any specific attribute just like it would on models that weren't nested, and it prevents parent model from being saved if a nested model is not valid :)

[bvisonl]

@baelter Can you maybe provide a sample of a Model with NestedModel validations? I am not sure how to test your code