before and after hooks now get the DAO instance instead of only the dataValues

lib/dao-validator.js

@@ -23,12 +23,11 @@ DaoValidator.prototype.hookValidate = function() {
     , errors = {}
     , errors = {}
 
 
   return new Utils.CustomEventEmitter(function(emitter) {
   return new Utils.CustomEventEmitter(function(emitter) {
-    self.model.daoFactory.runHooks('beforeValidate', self.model.dataValues, function(err, newValues) {
+    self.model.daoFactory.runHooks('beforeValidate', self.model, function(err) {
       if (!!err) {
       if (!!err) {
         return emitter.emit('error', err)
         return emitter.emit('error', err)
       }
       }
 
 
-      self.model.dataValues = newValues || self.model.dataValues
       errors = Utils._.extend(errors, validateAttributes.call(self))
       errors = Utils._.extend(errors, validateAttributes.call(self))
       errors = Utils._.extend(errors, validateModel.call(self))
       errors = Utils._.extend(errors, validateModel.call(self))
 
 
@@ -36,12 +35,11 @@ DaoValidator.prototype.hookValidate = function() {
         return emitter.emit('error', errors)
         return emitter.emit('error', errors)
       }
       }
 
 
-      self.model.daoFactory.runHooks('afterValidate', self.model.dataValues, function(err, newValues) {
+      self.model.daoFactory.runHooks('afterValidate', self.model, function(err) {
         if (!!err) {
         if (!!err) {
           return emitter.emit('error', err)
           return emitter.emit('error', err)
         }
         }
 
 
-        self.model.dataValues = newValues || self.model.dataValues
         emitter.emit('success', self.model)
         emitter.emit('success', self.model)
       })
       })
     })
     })

lib/dao.js

@@ -12,7 +12,7 @@ module.exports = (function() {
     this.__options                   = this.__factory.options
     this.__options                   = this.__factory.options
     this.options                     = options
     this.options                     = options
     this.hasPrimaryKeys              = this.__factory.options.hasPrimaryKeys
     this.hasPrimaryKeys              = this.__factory.options.hasPrimaryKeys
-    // What is selected values even used for? 
+    // What is selected values even used for?
     this.selectedValues              = options.include ? _.omit(values, options.includeNames) : values
     this.selectedValues              = options.include ? _.omit(values, options.includeNames) : values
     this.__eagerlyLoadedAssociations = []
     this.__eagerlyLoadedAssociations = []
     this.isNewRecord                 = options.isNewRecord
     this.isNewRecord                 = options.isNewRecord
@@ -157,7 +157,7 @@ module.exports = (function() {
       // If not raw, and there's a customer setter
       // If not raw, and there's a customer setter
       if (!options.raw && this._customSetters[key]) {
       if (!options.raw && this._customSetters[key]) {
         this._customSetters[key].call(this, value, key)
         this._customSetters[key].call(this, value, key)
-      } else { 
+      } else {
         // Check if we have included models, and if this key matches the include model names/aliases
         // Check if we have included models, and if this key matches the include model names/aliases
 
 
         if (this.options && this.options.include && this.options.includeNames.indexOf(key) !== -1) {
         if (this.options && this.options.include && this.options.includeNames.indexOf(key) !== -1) {
@@ -375,35 +375,40 @@ module.exports = (function() {
           hook          = 'Update'
           hook          = 'Update'
         }
         }
 
 
-        self.__factory.runHooks('before' + hook, values, function(err, newValues) {
+        // Add the values to the DAO
+        self.dataValues = _.extend(self.dataValues, values)
+
+        // Run the beforeCreate / beforeUpdate hook
+        self.__factory.runHooks('before' + hook, self, function(err) {
           if (!!err) {
           if (!!err) {
             return emitter.emit('error', err)
             return emitter.emit('error', err)
           }
           }
 
 
-          args[2] = values = newValues || values
-          // Newest values need to be on the dao since the dao is returned from the query interface
-          self.dataValues = _.extend(self.dataValues, values)
+          // dataValues might have changed inside the hook, rebuild
+          // the values hash
+          values = {}
+
+          options.fields.forEach(function(field) {
+            if (self.dataValues[field] !== undefined) {
+              values[field] = self.dataValues[field]
+            }
+          })
+          args[2] = values
 
 
           self.QueryInterface[query].apply(self.QueryInterface, args)
           self.QueryInterface[query].apply(self.QueryInterface, args)
             .proxy(emitter, {events: ['sql', 'error']})
             .proxy(emitter, {events: ['sql', 'error']})
             .success(function(result) {
             .success(function(result) {
               // Transfer database generated values (defaults, autoincrement, etc)
               // Transfer database generated values (defaults, autoincrement, etc)
-              values = _.extend(values, result.values) 
+              values = _.extend(values, result.dataValues)
 
 
               // Ensure new values are on DAO, and reset previousDataValues
               // Ensure new values are on DAO, and reset previousDataValues
               result.dataValues = _.extend(result.dataValues, values)
               result.dataValues = _.extend(result.dataValues, values)
               result._previousDataValues = _.clone(result.dataValues)
               result._previousDataValues = _.clone(result.dataValues)
 
 
-              self.__factory.runHooks('after' + hook, values, function(err, newValues) {
+              self.__factory.runHooks('after' + hook, result, function(err) {
                 if (!!err) {
                 if (!!err) {
                   return emitter.emit('error', err)
                   return emitter.emit('error', err)
                 }
                 }
-
-                if (newValues) {
-                  // Repeat value assignment incase afterHook changed anything
-                  result.dataValues = _.extend(result.dataValues, newValues)
-                  result._previousDataValues = _.clone(result.dataValues)
-                }
                 emitter.emit('success', result)
                 emitter.emit('success', result)
               })
               })
             })
             })
@@ -486,7 +491,7 @@ module.exports = (function() {
       , query = null
       , query = null
 
 
     return new Utils.CustomEventEmitter(function(emitter) {
     return new Utils.CustomEventEmitter(function(emitter) {
-      self.daoFactory.runHooks(self.daoFactory.options.hooks.beforeDestroy, self.dataValues, function(err) {
+      self.daoFactory.runHooks(self.daoFactory.options.hooks.beforeDestroy, self, function(err) {
         if (!!err) {
         if (!!err) {
           return emitter.emit('error', err)
           return emitter.emit('error', err)
         }
         }
@@ -507,7 +512,7 @@ module.exports = (function() {
           emitter.emit('error', err)
           emitter.emit('error', err)
         })
         })
         .success(function(results) {
         .success(function(results) {
-          self.daoFactory.runHooks(self.daoFactory.options.hooks.afterDestroy, self.dataValues, function(err) {
+          self.daoFactory.runHooks(self.daoFactory.options.hooks.afterDestroy, self, function(err) {
             if (!!err) {
             if (!!err) {
               return emitter.emit('error', err)
               return emitter.emit('error', err)
             }
             }

test/dao-factory.test.js

@@ -1686,10 +1686,10 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
     beforeEach(function(done) {
     beforeEach(function(done) {
       this.User = this.sequelize.define('User', {username: DataTypes.STRING }, { paranoid: true })
       this.User = this.sequelize.define('User', {username: DataTypes.STRING }, { paranoid: true })
       this.Project = this.sequelize.define('Project', { title: DataTypes.STRING }, { paranoid: true })
       this.Project = this.sequelize.define('Project', { title: DataTypes.STRING }, { paranoid: true })
-      
+
       this.Project.hasMany(this.User)
       this.Project.hasMany(this.User)
       this.User.hasMany(this.Project)
       this.User.hasMany(this.Project)
-      
+
       var self = this
       var self = this
       this.sequelize.sync({ force: true }).success(function() {
       this.sequelize.sync({ force: true }).success(function() {
         self.User.bulkCreate([{
         self.User.bulkCreate([{
@@ -1777,7 +1777,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
         }
         }
       }).error(done)
       }).error(done)
     })
     })
-  
+
   })
   })
 
 
 })
 })

test/hooks.test.js

@@ -6994,4 +6994,138 @@ describe(Support.getTestDialectTeaser("Hooks"), function () {
       })
       })
     })
     })
   })
   })
+
+  describe('passing DAO instances', function() {
+
+    describe('beforeValidate / afterValidate', function() {
+      it('should pass a DAO instance to the hook', function(done){
+        var User = this.sequelize.define('User', {
+          username: DataTypes.STRING
+        }, {
+          hooks: {
+            beforeValidate: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            },
+            afterValidate: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            }
+          }
+        })
+
+        User.sync({ force: true }).success(function() {
+          User.create({ username: 'bob' }).success(function(user) {
+            done()
+          })
+        })
+      })
+    })
+
+    describe('beforeCreate / afterCreate', function() {
+      it('should pass a DAO instance to the hook', function(done){
+        var User = this.sequelize.define('User', {
+          username: DataTypes.STRING
+        }, {
+          hooks: {
+            beforeCreate: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            },
+            afterCreate: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            }
+          }
+        })
+
+        User.sync({ force: true }).success(function() {
+          User.create({ username: 'bob' }).success(function(user) {
+            done()
+          })
+        })
+      })
+    })
+
+    describe('beforeDestroy / afterDestroy', function() {
+      it('should pass a DAO instance to the hook', function(done){
+        var User = this.sequelize.define('User', {
+          username: DataTypes.STRING
+        }, {
+          hooks: {
+            beforeDestroy: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            },
+            afterDestroy: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            }
+          }
+        })
+
+        User.sync({ force: true }).success(function() {
+          User.create({ username: 'bob' }).success(function(user) {
+            user.destroy().success(function() {
+              done()
+            })
+          })
+        })
+      })
+    })
+
+    describe('beforeDelete / afterDelete', function() {
+      it('should pass a DAO instance to the hook', function(done){
+        var User = this.sequelize.define('User', {
+          username: DataTypes.STRING
+        }, {
+          hooks: {
+            beforeDelete: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            },
+            afterDelete: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            }
+          }
+        })
+
+        User.sync({ force: true }).success(function() {
+          User.create({ username: 'bob' }).success(function(user) {
+            user.destroy().success(function() {
+              done()
+            })
+          })
+        })
+      })
+    })
+
+    describe('beforeUpdate / afterUpdate', function() {
+      it('should pass a DAO instance to the hook', function(done){
+        var User = this.sequelize.define('User', {
+          username: DataTypes.STRING
+        }, {
+          hooks: {
+            beforeUpdate: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            },
+            afterUpdate: function(user, fn) {
+              expect(user).to.be.instanceof(User.DAO)
+              fn()
+            }
+          }
+        })
+
+        User.sync({ force: true }).success(function() {
+          User.create({ username: 'bob' }).success(function(user) {
+            user.save({ username: 'bawb' }).success(function() {
+              done()
+            })
+          })
+        })
+      })
+    })
+  })
 })
 })