hasMany setter uses bulk create and destroy to create and remove associations

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

@@ -42,35 +42,52 @@ module.exports = (function() {
 
 
   HasManyDoubleLinked.prototype.injectSetter = function(emitterProxy, oldAssociations, newAssociations) {
   HasManyDoubleLinked.prototype.injectSetter = function(emitterProxy, oldAssociations, newAssociations) {
     var self = this
     var self = this
-
-    destroyObsoleteAssociations
-      .call(this, oldAssociations, newAssociations)
-      .on('sql', function(sql) { emitterProxy.emit('sql', sql) })
-      .error(function(err) { emitterProxy.emit('error', err) })
-      .success(function() {
-        var chainer             = new Utils.QueryChainer
+      , chainer             = new Utils.QueryChainer()
       , association         = self.__factory.target.associations[self.__factory.associationAccessor]
       , association         = self.__factory.target.associations[self.__factory.associationAccessor]
       , foreignIdentifier   = association.isSelfAssociation ? association.foreignIdentifier : association.identifier
       , foreignIdentifier   = association.isSelfAssociation ? association.foreignIdentifier : association.identifier
+      , obsoleteAssociations = oldAssociations.filter(function (old) {
+          // Return only those old associations that are not found in new
+          return !Utils._.find(newAssociations, function (obj) {
+            return obj.id === old.id
+          })
+        })
      , unassociatedObjects = newAssociations.filter(function (obj) { 
      , unassociatedObjects = newAssociations.filter(function (obj) { 
           return !Utils._.find(oldAssociations, function (old) {
           return !Utils._.find(oldAssociations, function (old) {
             return obj.id === old.id
             return obj.id === old.id
           }) 
           }) 
         })
         })
 
 
-        unassociatedObjects.forEach(function(unassociatedObject) {
+    if (obsoleteAssociations.length > 0) {
+      var foreignIds = obsoleteAssociations.map(function (associatedObject) {
+            return associatedObject.id
+          })
+        , primaryKeys      = Object.keys(self.__factory.connectorDAO.rawAttributes)
+        , foreignKey       = primaryKeys.filter(function(pk) { return pk != self.__factory.identifier })[0]
+
+      var where = {}
+      where[self.__factory.identifier] = self.instance.id
+      where[foreignKey] = foreignIds
+
+      chainer.add(self.__factory.connectorDAO.destroy(where))
+    }
+
+    if (unassociatedObjects.length > 0) {
+      var bulk = unassociatedObjects.map(function(unassociatedObject) {
         var attributes = {}
         var attributes = {}
         attributes[self.__factory.identifier] = self.instance.id
         attributes[self.__factory.identifier] = self.instance.id
         attributes[foreignIdentifier] = unassociatedObject.id
         attributes[foreignIdentifier] = unassociatedObject.id
 
 
-          chainer.add(self.__factory.connectorDAO.create(attributes))
+        return attributes
       })
       })
 
 
+      chainer.add(self.__factory.connectorDAO.bulkCreate(bulk))
+    } 
+
     chainer
     chainer
       .run()
       .run()
       .success(function() { emitterProxy.emit('success', newAssociations) })
       .success(function() { emitterProxy.emit('success', newAssociations) })
       .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) })
-      })
   }
   }
 
 
   HasManyDoubleLinked.prototype.injectAdder = function(emitterProxy, newAssociation) {
   HasManyDoubleLinked.prototype.injectAdder = function(emitterProxy, newAssociation) {
@@ -87,57 +104,5 @@ module.exports = (function() {
       .on('sql', function(sql) { emitterProxy.emit('sql', sql) })
       .on('sql', function(sql) { emitterProxy.emit('sql', sql) })
   }
   }
 
 
-  // private
-
-  var destroyObsoleteAssociations = function(oldAssociations, newAssociations) {
-    var self = this
-
-    return new Utils.CustomEventEmitter(function(emitter) {
-      var chainer = new Utils.QueryChainer()
-      var foreignIdentifier = self.__factory.target.associations[self.__factory.associationAccessor].identifier
-      var obsoleteAssociations = oldAssociations.filter(function (old) {
-        // Return only those old associations that are not found in new
-        return !Utils._.find(newAssociations, function (obj) {
-          return obj.id === old.id
-        })
-      })
-
-      if (obsoleteAssociations.length === 0) {
-        return emitter.emit('success', null)
-      }
-
-      obsoleteAssociations.forEach(function(associatedObject) {
-        var where            = {}
-          , primaryKeys      = Object.keys(self.__factory.connectorDAO.rawAttributes)
-          , foreignKey       = primaryKeys.filter(function(pk) { return pk != self.__factory.identifier })[0]
-          , notFoundEmitters = []
-
-        where[self.__factory.identifier] = self.instance.id
-        where[foreignKey] = associatedObject.id
-
-        self.__factory.connectorDAO
-          .find({ where: where })
-          .success(function(connector) {
-            if (connector === null) {
-              notFoundEmitters.push(null)
-            } else {
-              chainer.add(connector.destroy())
-            }
-
-            if ((chainer.emitters.length + notFoundEmitters.length) === obsoleteAssociations.length) {
-              // found all obsolete connectors and will delete them now
-              chainer
-                .run()
-                .success(function() { emitter.emit('success', null) })
-                .error(function(err) { emitter.emit('error', err) })
-                .on('sql', function(sql) { emitter.emit('sql', sql) })
-            }
-          })
-          .error(function(err) { emitter.emit('error', err) })
-          .on('sql', function(sql) { emitter.emit('sql', sql) })
-      })
-    }).run()
-  }
-
   return HasManyDoubleLinked
   return HasManyDoubleLinked
 })()
 })()

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

@@ -7,7 +7,8 @@ module.exports = (function() {
   }
   }
 
 
   HasManySingleLinked.prototype.injectGetter = function(options) {
   HasManySingleLinked.prototype.injectGetter = function(options) {
-    var where = {}, options = options || {}
+    var where = {}
+    options = options || {}
 
 
     where[this.__factory.identifier] = this.instance.id
     where[this.__factory.identifier] = this.instance.id
 
 
@@ -17,7 +18,6 @@ module.exports = (function() {
 
 
   HasManySingleLinked.prototype.injectSetter = function(emitter, oldAssociations, newAssociations) {
   HasManySingleLinked.prototype.injectSetter = function(emitter, oldAssociations, newAssociations) {
     var self    = this
     var self    = this
-      , options = this.__factory.options
       , chainer = new Utils.QueryChainer()
       , chainer = new Utils.QueryChainer()
       , obsoleteAssociations = oldAssociations.filter(function (old) { 
       , obsoleteAssociations = oldAssociations.filter(function (old) { 
           return !Utils._.find(newAssociations, function (obj) {
           return !Utils._.find(newAssociations, function (obj) {
@@ -29,23 +29,31 @@ module.exports = (function() {
             return obj.id === old.id
             return obj.id === old.id
           }) 
           }) 
         })
         })
+      , update
 
 
+    if (obsoleteAssociations.length > 0) {
       // clear the old associations
       // clear the old associations
-    obsoleteAssociations.forEach(function(associatedObject) {
-      associatedObject[self.__factory.identifier] = null
-      chainer.add(associatedObject.save())
-    })
+      var obsoleteIds = obsoleteAssociations.map(function(associatedObject) { return associatedObject.id })
+
+      update = {} 
+      update[self.__factory.identifier] = null
+      chainer.add(this.__factory.target.update(update, { id: obsoleteIds }))
+    } 
 
 
+    if (unassociatedObjects.length > 0) {
       // set the new associations
       // set the new associations
-    unassociatedObjects.forEach(function(associatedObject) {
-      associatedObject[self.__factory.identifier] = self.instance.id
-      chainer.add(associatedObject.save())
-    })
+      var unassociatedIds = unassociatedObjects.map(function(associatedObject) { return associatedObject.id })
+
+      update = {}
+      update[self.__factory.identifier] = self.instance.id
+      chainer.add(this.__factory.target.update(update, { id: unassociatedIds }))
+    }
 
 
     chainer
     chainer
       .run()
       .run()
       .success(function() { emitter.emit('success', newAssociations) })
       .success(function() { emitter.emit('success', newAssociations) })
       .error(function(err) { emitter.emit('error', err) })
       .error(function(err) { emitter.emit('error', err) })
+      .on('sql', function(sql) { emitterProxy.emit('sql', sql) })
   }
   }
 
 
   HasManySingleLinked.prototype.injectAdder = function(emitterProxy, newAssociation) {
   HasManySingleLinked.prototype.injectAdder = function(emitterProxy, newAssociation) {