Merge pull request #797 from durango/bulk

bulkCreate() now has a third argument which gives you the ability to validate each row before attempting to bulkInsert.

lib/dao-factory.js

@@ -434,13 +434,31 @@ module.exports = (function() {
    * generated IDs and other default values in a way that can be mapped to
    * generated IDs and other default values in a way that can be mapped to
    * multiple records
    * multiple records
    */
    */
-  DAOFactory.prototype.bulkCreate = function(records, fields) {
+  DAOFactory.prototype.bulkCreate = function(records, fields, options) {
+    options = options || {}
+    options.validate = options.validate || false
+    fields = fields || []
+
     var self          = this
     var self          = this
-      , daos          = records.map(function(v) { return self.build(v) })
       , updatedAtAttr = self.options.underscored ? 'updated_at' : 'updatedAt'
       , updatedAtAttr = self.options.underscored ? 'updated_at' : 'updatedAt'
       , createdAtAttr = self.options.underscored ? 'created_at' : 'createdAt'
       , createdAtAttr = self.options.underscored ? 'created_at' : 'createdAt'
-
-    fields = fields || []
+      , errors        = []
+      , daos          = records.map(function(v) {
+                          var build = self.build(v)
+                          if (options.validate === true) {
+                            var valid = build.validate({skip: fields})
+                            if (valid !== null) {
+                              errors[errors.length] = {record: v, errors: valid}
+                            }
+                          }
+                          return build
+                        })
+
+    if (options.validate === true && errors.length > 0) {
+      return new Utils.CustomEventEmitter(function(emitter) {
+        emitter.emit('error', errors)
+      }).run()
+    }
 
 
     // we will re-create from DAOs, which may have set up default attributes
     // we will re-create from DAOs, which may have set up default attributes
     records = []
     records = []
@@ -458,7 +476,7 @@ module.exports = (function() {
         values[updatedAtAttr] = Utils.now()
         values[updatedAtAttr] = Utils.now()
       }
       }
 
 
-      records.push(values);
+      records.push(values)
     })
     })
 
 
     // Validate enums
     // Validate enums

lib/dao-validator.js

 var Validator = require("validator")
 var Validator = require("validator")
   , Utils     = require("./utils")
   , Utils     = require("./utils")
 
 
-var DaoValidator = module.exports = function(model) {
+var DaoValidator = module.exports = function(model, options) {
+  options = options || {}
+  options.skip = options.skip || []
+
   this.model = model
   this.model = model
+  this.options = options
 }
 }
 
 
 DaoValidator.prototype.validate = function() {
 DaoValidator.prototype.validate = function() {
@@ -32,17 +36,19 @@ var validateModel = function() {
 }
 }
 
 
 var validateAttributes = function() {
 var validateAttributes = function() {
-  var errors = {}
+  var self = this
+    , errors = {}
 
 
   // for each field and value
   // for each field and value
   Utils._.each(this.model.dataValues, function(value, field) {
   Utils._.each(this.model.dataValues, function(value, field) {
-    var rawAttribute   = this.model.rawAttributes[field]
+    var rawAttribute   = self.model.rawAttributes[field]
       , hasAllowedNull = ((rawAttribute === undefined || rawAttribute.allowNull === true) && ((value === null) || (value === undefined)))
       , hasAllowedNull = ((rawAttribute === undefined || rawAttribute.allowNull === true) && ((value === null) || (value === undefined)))
+      , isSkipped      = self.options.skip.length > 0 && self.options.skip.indexOf(field) === -1
 
 
-    if (this.model.validators.hasOwnProperty(field) && !hasAllowedNull) {
-      errors = Utils._.merge(errors, validateAttribute.call(this, value, field))
+    if (self.model.validators.hasOwnProperty(field) && !hasAllowedNull && !isSkipped) {
+      errors = Utils._.merge(errors, validateAttribute.call(self, value, field))
     }
     }
-  }.bind(this)) // for each field
+  })
 
 
   return errors
   return errors
 }
 }

lib/dao.js

@@ -201,8 +201,8 @@ module.exports = (function() {
    *
    *
    * @return null if and only if validation successful; otherwise an object containing { field name : [error msgs] } entries.
    * @return null if and only if validation successful; otherwise an object containing { field name : [error msgs] } entries.
    */
    */
-  DAO.prototype.validate = function() {
-    var validator = new DaoValidator(this)
+  DAO.prototype.validate = function(object) {
+    var validator = new DaoValidator(this, object)
       , errors    = validator.validate()
       , errors    = validator.validate()
 
 
     return (Utils._.isEmpty(errors) ? null : errors)
     return (Utils._.isEmpty(errors) ? null : errors)

test/dao-factory.test.js

@@ -715,6 +715,68 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
       })
       })
     })
     })
 
 
+    it('emits an error when validate is set to true', function(done) {
+      var Tasks = this.sequelize.define('Task', {
+        name: {
+          type: Sequelize.STRING,
+          validate: {
+            notNull: { args: true, msg: 'name cannot be null' }
+          }
+        },
+        code: {
+          type: Sequelize.STRING,
+          validate: {
+            len: [3, 10]
+          }
+        }
+      })
+
+      Tasks.sync({ force: true }).success(function() {
+        Tasks.bulkCreate([
+          {name: 'foo', code: '123'},
+          {code: '1234'},
+          {name: 'bar', code: '1'}
+        ], null, {validate: true}).error(function(errors) {
+          expect(errors).to.not.be.null
+          expect(errors).to.be.instanceof(Array)
+          expect(errors).to.have.length(2)
+          expect(errors[0].record.code).to.equal('1234')
+          expect(errors[0].errors.name[0]).to.equal('name cannot be null')
+          expect(errors[1].record.name).to.equal('bar')
+          expect(errors[1].record.code).to.equal('1')
+          expect(errors[1].errors.code[0]).to.equal('String is not in range: code')
+          done()
+        })
+      })
+    })
+
+    it("doesn't emit an error when validate is set to true but our selectedValues are fine", function(done) {
+      var Tasks = this.sequelize.define('Task', {
+        name: {
+          type: Sequelize.STRING,
+          validate: {
+            notNull: { args: true, msg: 'name cannot be null' }
+          }
+        },
+        code: {
+          type: Sequelize.STRING,
+          validate: {
+            len: [3, 10]
+          }
+        }
+      })
+
+      Tasks.sync({ force: true }).success(function() {
+        Tasks.bulkCreate([
+          {name: 'foo', code: '123'},
+          {code: '1234'}
+        ], ['code'], {validate: true}).success(function() {
+          // we passed!
+          done()
+        })
+      })
+    })
+
     describe('enums', function() {
     describe('enums', function() {
       it('correctly restores enum values', function(done) {
       it('correctly restores enum values', function(done) {
         var self = this
         var self = this