Merge pull request #640 from tremby/model-validations

Add model validations option

README.md

@@ -78,6 +78,9 @@ A very basic roadmap. Chances aren't too bad, that not mentioned things are impl
 - encapsulate attributes if a dao inside the attributes property
 - ~~add getters and setters for dao~~ Implemented in [#538](https://github.com/sequelize/sequelize/pull/538), thanks to iamjochem
 - add proper error message everywhere
+- refactor validate() output data structure, separating field-specific errors
+  from general model validator errors (i.e.
+  `{fields: {field1: ['field1error1']}, model: ['modelError1']}` or similar)
 
 
 ## Collaboration 2.0 ##

lib/dao-factory.js

@@ -21,6 +21,14 @@ module.exports = (function() {
       schemaDelimiter: ''
     }, options || {})
 
+    // error check options
+    Utils._.each(options.validate, function(validator, validatorType) {
+      if (Utils._.contains(Utils._.keys(attributes), validatorType))
+        throw new Error("A model validator function must not have the same name as a field. Model: " + name + ", field/validation name: " + validatorType)
+      if (!Utils._.isFunction(validator))
+        throw new Error("Members of the validate option must be functions. Model: " + name + ", error with validate member " + validatorType)
+    })
+
     this.name = name
     if (!this.options.tableName) {
       this.tableName = this.options.freezeTableName ? name : Utils.pluralize(name)
@@ -30,9 +38,6 @@ module.exports = (function() {
     this.rawAttributes = attributes
     this.daoFactoryManager = null // defined in init function
     this.associations = {}
-
-    // extract validation
-    this.validate = this.options.validate || {}
   }
 
   Object.defineProperty(DAOFactory.prototype, 'attributes', {

lib/dao.js

@@ -269,6 +269,15 @@ module.exports = (function() {
       } // if field has validator set
     }) // for each field
 
+    // for each model validator for this DAO
+    Utils._.each(self.__options.validate, function(validator, validatorType) {
+      try {
+        validator.apply(self)
+      } catch (err) {
+        failures[validatorType] = [err.message] // TODO: data structure needs to change for 2.0
+      }
+    })
+
     return (Utils._.isEmpty(failures) ? null : failures)
   }
 

spec/dao-factory.spec.js

@@ -70,6 +70,34 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
         })
       }.bind(this), 'Invalid DAO definition. Only one autoincrement field allowed.')
     })
+
+    it('throws an error if a custom model-wide validation is not a function', function() {
+      Helpers.assertException(function() {
+        this.sequelize.define('Foo', {
+          field: {
+            type: Sequelize.INTEGER
+          }
+        }, {
+          validate: {
+            notFunction: 33
+          }
+        })
+      }.bind(this), 'Members of the validate option must be functions. Model: Foo, error with validate member notFunction')
+    })
+
+    it('throws an error if a custom model-wide validation has the same name as a field', function() {
+      Helpers.assertException(function() {
+        this.sequelize.define('Foo', {
+          field: {
+            type: Sequelize.INTEGER
+          }
+        }, {
+          validate: {
+            field: function() {}
+          }
+        })
+      }.bind(this), 'A model validator function must not have the same name as a field. Model: Foo, field/validation name: field')
+    })
   })
 
   describe('build', function() {

spec/dao.validations.spec.js

@@ -306,5 +306,34 @@ describe(Helpers.getTestDialectTeaser("DAO"), function() {
       var successfulUser2 = User.build({ age: 1 })
       expect(successfulUser2.validate()).toBeNull()
     })
+
+    it('validates a model with custom model-wide validation methods', function() {
+      var Foo = this.sequelize.define('Foo' + Math.random(), {
+        field1: {
+          type: Sequelize.INTEGER,
+          allowNull: true
+        },
+        field2: {
+          type: Sequelize.INTEGER,
+          allowNull: true
+        }
+      }, {
+        validate: {
+          xnor: function() {
+            if ((this.field1 === null) === (this.field2 === null)) {
+              throw new Error('xnor failed');
+            }
+          }
+        }
+      })
+
+      var failingFoo = Foo.build({ field1: null, field2: null })
+        , errors     = failingFoo.validate()
+      expect(errors).not.toBeNull()
+      expect(errors).toEqual({ 'xnor': ['xnor failed'] })
+
+      var successfulFoo = Foo.build({ field1: 33, field2: null })
+      expect(successfulFoo.validate()).toBeNull()
+    })
   })
 })