Merge pull request #1216 from saschagehlich/feature/add-association-transaction-support

Added transaction support for hasMany `.addAssociation`

lib/associations/has-many-double-linked.js

@@ -21,7 +21,7 @@ module.exports = (function() {
         , options = _options || {}
         , options = _options || {}
         , queryOptions = {}
         , queryOptions = {}
         , targetAssociation = self.association.targetAssociation
         , targetAssociation = self.association.targetAssociation
-        
+
       //fully qualify
       //fully qualify
       var instancePrimaryKeys = Object.keys(self.instance.daoFactory.primaryKeys)
       var instancePrimaryKeys = Object.keys(self.instance.daoFactory.primaryKeys)
         , instancePrimaryKey = instancePrimaryKeys.length > 0 ? instancePrimaryKeys[0] : 'id'
         , instancePrimaryKey = instancePrimaryKeys.length > 0 ? instancePrimaryKeys[0] : 'id'
@@ -187,11 +187,17 @@ module.exports = (function() {
   HasManyDoubleLinked.prototype.injectAdder = function(emitterProxy, newAssociation, additionalAttributes, exists) {
   HasManyDoubleLinked.prototype.injectAdder = function(emitterProxy, newAssociation, additionalAttributes, exists) {
     var attributes          = {}
     var attributes          = {}
       , targetAssociation   = this.association.targetAssociation
       , targetAssociation   = this.association.targetAssociation
-      , foreignIdentifier   = targetAssociation.isSelfAssociation ? targetAssociation.foreignIdentifier : targetAssociation.identifier;
+      , foreignIdentifier   = targetAssociation.isSelfAssociation ? targetAssociation.foreignIdentifier : targetAssociation.identifier
+      , options = {}
 
 
     var sourceKeys = Object.keys(this.association.source.primaryKeys);
     var sourceKeys = Object.keys(this.association.source.primaryKeys);
     var targetKeys = Object.keys(this.association.target.primaryKeys);
     var targetKeys = Object.keys(this.association.target.primaryKeys);
 
 
+    if ((additionalAttributes || {}).transaction instanceof Transaction) {
+      options.transaction = additionalAttributes.transaction
+      delete additionalAttributes.transaction
+    }
+
     attributes[this.association.identifier] = ((sourceKeys.length === 1) ? this.instance[sourceKeys[0]] : this.instance.id)
     attributes[this.association.identifier] = ((sourceKeys.length === 1) ? this.instance[sourceKeys[0]] : this.instance.id)
     attributes[foreignIdentifier] = ((targetKeys.length === 1) ? newAssociation[targetKeys[0]] : newAssociation.id)
     attributes[foreignIdentifier] = ((targetKeys.length === 1) ? newAssociation[targetKeys[0]] : newAssociation.id)
 
 
@@ -207,7 +213,7 @@ module.exports = (function() {
     } else {
     } else {
       attributes = Utils._.defaults(attributes, newAssociation[targetAssociation.through.name], additionalAttributes)
       attributes = Utils._.defaults(attributes, newAssociation[targetAssociation.through.name], additionalAttributes)
 
 
-      this.association.through.create(attributes)
+      this.association.through.create(attributes, options)
         .success(function() { emitterProxy.emit('success', newAssociation) })
         .success(function() { emitterProxy.emit('success', newAssociation) })
         .error(function(err) { emitterProxy.emit('error', err) })
         .error(function(err) { emitterProxy.emit('error', err) })
         .on('sql', function(sql) { emitterProxy.emit('sql', sql) })
         .on('sql', function(sql) { emitterProxy.emit('sql', sql) })

lib/associations/has-many-single-linked.js

@@ -108,13 +108,19 @@ module.exports = (function() {
       .on('sql', function(sql) { emitter.emit('sql', sql) })
       .on('sql', function(sql) { emitter.emit('sql', sql) })
   }
   }
 
 
-  HasManySingleLinked.prototype.injectAdder = function(emitterProxy, newAssociation) {
+  HasManySingleLinked.prototype.injectAdder = function(emitterProxy, newAssociation, additionalAttributes) {
     var primaryKeys = Object.keys(this.instance.daoFactory.primaryKeys)
     var primaryKeys = Object.keys(this.instance.daoFactory.primaryKeys)
       , primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : 'id'
       , primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : 'id'
+      , options = {}
+
+    if ((additionalAttributes || {}).transaction instanceof Transaction) {
+      options.transaction = additionalAttributes.transaction
+      delete additionalAttributes.transaction
+    }
 
 
     newAssociation[this.__factory.identifier] = this.instance[primaryKey]
     newAssociation[this.__factory.identifier] = this.instance[primaryKey]
 
 
-    newAssociation.save()
+    newAssociation.save(options)
       .success(function() { emitterProxy.emit('success', newAssociation) })
       .success(function() { emitterProxy.emit('success', newAssociation) })
       .error(function(err) { emitterProxy.emit('error', err) })
       .error(function(err) { emitterProxy.emit('error', err) })
       .on('sql', function(sql) { emitterProxy.emit('sql', sql) })
       .on('sql', function(sql) { emitterProxy.emit('sql', sql) })

test/associations/has-many.test.js

@@ -265,6 +265,40 @@ describe(Support.getTestDialectTeaser("HasMany"), function() {
       })
       })
     })
     })
 
 
+    describe('addAssociations', function() {
+      it('supports transactions', function(done) {
+        Support.prepareTransactionTest(this.sequelize, function(sequelize) {
+          var Article = sequelize.define('Article', { 'title': DataTypes.STRING })
+            , Label   = sequelize.define('Label', { 'text': DataTypes.STRING })
+
+          Article.hasMany(Label)
+
+          sequelize.sync({ force: true }).success(function() {
+            Article.create({ title: 'foo' }).success(function(article) {
+              Label.create({ text: 'bar' }).success(function(label) {
+                sequelize.transaction(function(t) {
+                  article.addLabel(label, { transaction: t }).success(function() {
+                    Label
+                      .findAll({ where: { ArticleId: article.id }, transaction: undefined })
+                      .success(function(labels) {
+                        expect(labels.length).to.equal(0)
+
+                        Label
+                          .findAll({ where: { ArticleId: article.id }, transaction: t })
+                          .success(function(labels) {
+                            expect(labels.length).to.equal(1)
+                            t.rollback().success(function() { done() })
+                          })
+                      })
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
     it("clears associations when passing null to the set-method with omitNull set to true", function(done) {
     it("clears associations when passing null to the set-method with omitNull set to true", function(done) {
       this.sequelize.options.omitNull = true
       this.sequelize.options.omitNull = true
 
 
@@ -620,6 +654,36 @@ describe(Support.getTestDialectTeaser("HasMany"), function() {
       })
       })
     })
     })
 
 
+    describe('addAssociations', function() {
+      it('supports transactions', function(done) {
+        Support.prepareTransactionTest(this.sequelize, function(sequelize) {
+          var User = sequelize.define('User', { username: DataTypes.STRING })
+            , Task = sequelize.define('Task', { title: DataTypes.STRING })
+
+          User.hasMany(Task)
+          Task.hasMany(User)
+
+          sequelize.sync({ force: true }).success(function() {
+            User.create({ username: 'foo' }).success(function(user) {
+              Task.create({ title: 'task' }).success(function(task) {
+                sequelize.transaction(function(t){
+                  task.addUser(user, { transaction: t }).success(function() {
+                    task.hasUser(user).success(function(hasUser) {
+                      expect(hasUser).to.be.false
+                      task.hasUser(user, { transaction: t }).success(function(hasUser) {
+                        expect(hasUser).to.be.true
+                        t.rollback().success(function() { done() })
+                      })
+                    })
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+
     describe('optimizations using bulk create, destroy and update', function () {
     describe('optimizations using bulk create, destroy and update', function () {
       beforeEach(function (done) {
       beforeEach(function (done) {
         var self = this
         var self = this
@@ -820,7 +884,7 @@ describe(Support.getTestDialectTeaser("HasMany"), function() {
             Worker.hasMany(Task, { through: WorkerTasks })
             Worker.hasMany(Task, { through: WorkerTasks })
             Task.hasMany(Worker, { through: WorkerTasks })
             Task.hasMany(Worker, { through: WorkerTasks })
 
 
-            this.sequelize.sync().done(function(err) { 
+            this.sequelize.sync().done(function(err) {
               expect(err).not.to.be.ok
               expect(err).not.to.be.ok
               Worker.create().done(function (err, worker) {
               Worker.create().done(function (err, worker) {
                 expect(err).not.to.be.ok
                 expect(err).not.to.be.ok
@@ -878,7 +942,7 @@ describe(Support.getTestDialectTeaser("HasMany"), function() {
             Worker.hasMany(Task, { through: WorkerTasks })
             Worker.hasMany(Task, { through: WorkerTasks })
             Task.hasMany(Worker, { through: WorkerTasks })
             Task.hasMany(Worker, { through: WorkerTasks })
 
 
-            this.sequelize.sync().done(function(err) { 
+            this.sequelize.sync().done(function(err) {
               expect(err).not.to.be.ok
               expect(err).not.to.be.ok
               Worker.create().done(function (err, worker) {
               Worker.create().done(function (err, worker) {
                 expect(err).not.to.be.ok
                 expect(err).not.to.be.ok
@@ -909,7 +973,7 @@ describe(Support.getTestDialectTeaser("HasMany"), function() {
           Worker.hasMany(Task, { through: WorkerTasks })
           Worker.hasMany(Task, { through: WorkerTasks })
           Task.hasMany(Worker, { through: WorkerTasks })
           Task.hasMany(Worker, { through: WorkerTasks })
 
 
-          this.sequelize.sync().done(function(err) { 
+          this.sequelize.sync().done(function(err) {
             expect(err).not.to.be.ok
             expect(err).not.to.be.ok
             Worker.create({}).done(function (err, worker) {
             Worker.create({}).done(function (err, worker) {
               expect(err).not.to.be.ok
               expect(err).not.to.be.ok
@@ -924,7 +988,7 @@ describe(Support.getTestDialectTeaser("HasMany"), function() {
                       worker.getTasks().done(function (err, tasks) {
                       worker.getTasks().done(function (err, tasks) {
                         expect(tasks.length).to.equal(1)
                         expect(tasks.length).to.equal(1)
                         done()
                         done()
-                      })  
+                      })
                     })
                     })
                   })
                   })
                 })
                 })