Initial commit for join table model

Jan Aagaard Meier
Commit 8aa5d609 authored Aug 24, 2013 by Jan Aagaard Meier
Showing with 90 additions and 34 deletions
lib/associations/has-many-double-linked.js
lib/associations/has-many.js
--- a/lib/associations/has-many-double-linked.js
+++ b/lib/associations/has-many-double-linked.js
@@ -18,14 +18,13 @@ module.exports = (function() {
      where[self.__factory.connectorDAO.tableName+"."+self.__factory.identifier] = self.instance[instancePrimaryKey]
-      var primaryKeys = Object.keys(self.__factory.connectorDAO.rawAttributes)
+      var primaryKeys = Object.keys(self.__factory.connectorDAO.primaryKeys)
        , foreignKey  = primaryKeys.filter(function(pk) { return pk != self.__factory.identifier })[0]
        , foreignPrimary = Object.keys(self.__factory.target.primaryKeys)
      foreignPrimary = foreignPrimary.length === 1 ? foreignPrimary[0] : 'id'
      where[self.__factory.connectorDAO.tableName+"."+foreignKey] = {join: self.__factory.target.tableName+"."+foreignPrimary}
      if (options.where) {
        if (Array.isArray(options.where)) {
          smart = Utils.smartWhere([where, options.where], self.__factory.target.daoFactoryManager.sequelize.options.dialect)
@@ -53,23 +52,40 @@ module.exports = (function() {
    return customEventEmitter.run()
  }
-  HasManyDoubleLinked.prototype.injectSetter = function(emitterProxy, oldAssociations, newAssociations) {
+  HasManyDoubleLinked.prototype.injectSetter = function(emitterProxy, oldAssociations, newAssociations, defaultAttributes) {
    var self = this
      , chainer             = new Utils.QueryChainer()
      , association         = self.__factory.target.associations[self.__factory.associationAccessor]
-      , foreignIdentifier   = association.isSelfAssociation ? association.foreignIdentifier : association.identifier;
+      , foreignIdentifier   = association.isSelfAssociation ? association.foreignIdentifier : association.identifier
+      , obsoleteAssociations = []
+      , changedAssociations = []
+      , unassociatedObjects;
+    unassociatedObjects = newAssociations.filter(function (obj) {
+      return !Utils._.find(oldAssociations, function (old) {
+        return (!!obj[foreignIdentifier] && !!old[foreignIdentifier] ? obj[foreignIdentifier] === old[foreignIdentifier] : obj.id === old.id)
+      })
+    })
-    var obsoleteAssociations = oldAssociations.filter(function (old) {
+    oldAssociations.forEach(function (old) {
-          // Return only those old associations that are not found in new
+      var newObj = Utils._.find(newAssociations, function (obj) {
-          return !Utils._.find(newAssociations, function (obj) {
+        return (!!obj[foreignIdentifier] && !!old[foreignIdentifier] ? obj[foreignIdentifier] === old[foreignIdentifier] : obj.id === old.id)
-            return (!!obj[foreignIdentifier] && !!old[foreignIdentifier] ? obj[foreignIdentifier] === old[foreignIdentifier] : obj.id === old.id)
+      })
-          })
-        })
+      if (!newObj) {
-     , unassociatedObjects = newAssociations.filter(function (obj) {
+        obsoleteAssociations.push(obj)
-          return !Utils._.find(oldAssociations, function (old) {
+      } else if (association.customJoinTableModel) {
-            return (!!obj[foreignIdentifier] && !!old[foreignIdentifier] ? obj[foreignIdentifier] === old[foreignIdentifier] : obj.id === old.id)
+        var changedAssociation = {
-          })
+          where: {},
-        })
+          attributes: Utils._.defaults({}, newObj[self.__factory.connectorDAO.name], defaultAttributes)
+        }
+        changedAssociation.where[self.__factory.identifier] = self.instance[self.__factory.identifier] || self.instance.id
+        changedAssociation.where[foreignIdentifier] = newObj[foreignIdentifier] || newObj.id
+        changedAssociations.push(changedAssociation)
+      }
+    })
    if (obsoleteAssociations.length > 0) {
      var foreignIds = obsoleteAssociations.map(function (associatedObject) {
@@ -91,12 +107,22 @@ module.exports = (function() {
        attributes[self.__factory.identifier] = self.instance[self.__factory.identifier] || self.instance.id
        attributes[foreignIdentifier] = unassociatedObject[foreignIdentifier] || unassociatedObject.id
+        if (association.customJoinTableModel) {
+          attributes = Utils._.defaults(attributes, unassociatedObject[association.connectorDAO.name], defaultAttributes)
+        }
        return attributes
      })
      chainer.add(self.__factory.connectorDAO.bulkCreate(bulk))
    }
+    if (changedAssociations.length > 0) {
+      changedAssociations.forEach(function (assoc) {
+        chainer.add(self.__factory.connectorDAO.update(assoc.attributes, assoc.where))
+      })
+    }
    chainer
      .run()
      .success(function() { emitterProxy.emit('success', newAssociations) })
@@ -104,7 +130,7 @@ module.exports = (function() {
      .on('sql', function(sql) { emitterProxy.emit('sql', sql) })
  }
-  HasManyDoubleLinked.prototype.injectAdder = function(emitterProxy, newAssociation) {
+  HasManyDoubleLinked.prototype.injectAdder = function(emitterProxy, newAssociation, additionalAttributes, exists) {
    var attributes = {}
      , association         = this.__factory.target.associations[this.__factory.associationAccessor]
      , foreignIdentifier   = association.isSelfAssociation ? association.foreignIdentifier : association.identifier;
@@ -112,10 +138,21 @@ module.exports = (function() {
    attributes[this.__factory.identifier] = this.instance[this.__factory.identifier] || this.instance.id
    attributes[foreignIdentifier] = newAssociation[foreignIdentifier] || newAssociation.id
-    this.__factory.connectorDAO.create(attributes)
+    if (exists) { // implies customJoinTableModel === true
-      .success(function() { emitterProxy.emit('success', newAssociation) })
+      var where = attributes
-      .error(function(err) { emitterProxy.emit('error', err) })
+      attributes = Utils._.defaults({}, newAssociation[association.connectorDAO.name], additionalAttributes)
-      .on('sql', function(sql) { emitterProxy.emit('sql', sql) })
+      association.connectorDAO.update(attributes, where).proxy(emitterProxy)
+    } else {
+      if (association.customJoinTableModel === true) {
+        attributes = Utils._.defaults(attributes, newAssociation[association.connectorDAO.name], additionalAttributes)
+      }
+      this.__factory.connectorDAO.create(attributes)
+        .success(function() { emitterProxy.emit('success', newAssociation) })
+        .error(function(err) { emitterProxy.emit('error', err) })
+        .on('sql', function(sql) { emitterProxy.emit('sql', sql) })  
+    }
  }
  return HasManyDoubleLinked

--- a/lib/associations/has-many.js
+++ b/lib/associations/has-many.js
@@ -13,13 +13,20 @@ module.exports = (function() {
    this.options = options
    this.useJunctionTable = this.options.useJunctionTable === undefined ? true : this.options.useJunctionTable
    this.isSelfAssociation = (this.source.tableName === this.target.tableName)
+    this.customJoinTableModel = !!this.options.joinTableModel
-    var combinedTableName = Utils.combineTableNames(
+    var combinedTableName;
-      this.source.tableName,
+    if (this.customJoinTableModel) {
-      this.isSelfAssociation ? (this.options.as || this.target.tableName) : this.target.tableName
+      combinedTableName = this.options.joinTableModel.tableName
-    )
+    } else if (this.options.joinTableName) {
-    this.associationAccessor = this.combinedName = (this.options.joinTableName || combinedTableName)
+      combinedTableName = this.options.joinTableName
-    this.options.tableName = this.combinedName
+    } else {
+      Utils.combineTableNames(
+        this.source.tableName,
+        this.isSelfAssociation ? (this.options.as || this.target.tableName) : this.target.tableName
+      )
+    }
+    this.options.tableName = this.associationAccessor = this.combinedName = combinedTableName
    var as = (this.options.as || Utils.pluralize(this.target.tableName, this.target.options.language))
@@ -58,7 +65,17 @@ module.exports = (function() {
      combinedTableAttributes[this.identifier] = {type: keyType, primaryKey: true}
      combinedTableAttributes[this.foreignIdentifier] = {type: keyType, primaryKey: true}
-      this.connectorDAO = this.source.daoFactoryManager.sequelize.define(this.combinedName, combinedTableAttributes, this.options)
+      if (this.customJoinTableModel === true) {
+        this.connectorDAO = this.options.joinTableModel
+        this.connectorDAO.rawAttributes = Utils._.merge(this.connectorDAO.rawAttributes, combinedTableAttributes)
+        // FIXME - Should we do this? Normally join tables does not have an id, and it is not needed,
+        // but users might wonder what hapened if they defined the ID themselves
+        delete this.connectorDAO.rawAttributes.id
+        this.connectorDAO.init(this.connectorDAO.daoFactoryManager)
+      } else {
+        this.connectorDAO = this.source.daoFactoryManager.sequelize.define(this.combinedName, combinedTableAttributes, this.options)
+      }
      if (!this.isSelfAssociation) {
        this.target.associations[this.associationAccessor].connectorDAO = this.connectorDAO
@@ -89,7 +106,7 @@ module.exports = (function() {
      return new Class(self, this).injectGetter(options)
    }
-   obj[this.accessors.hasAll] = function(objects) {
+    obj[this.accessors.hasAll] = function(objects) {
      var instance = this;
      var customEventEmitter = new Utils.CustomEventEmitter(function() {
        instance[self.accessors.get]()
@@ -132,7 +149,7 @@ module.exports = (function() {
  HasMany.prototype.injectSetter = function(obj) {
    var self = this
-    obj[this.accessors.set] = function(newAssociatedObjects) {
+    obj[this.accessors.set] = function(newAssociatedObjects, defaultAttributes) {
      if (newAssociatedObjects === null) {
        newAssociatedObjects = []
      }
@@ -144,7 +161,7 @@ module.exports = (function() {
        instance[self.accessors.get]()
          .success(function(oldAssociatedObjects) {
            var Class = self.connectorDAO ? HasManyMultiLinked : HasManySingleLinked
-            new Class(self, instance).injectSetter(emitter, oldAssociatedObjects, newAssociatedObjects)
+            new Class(self, instance).injectSetter(emitter, oldAssociatedObjects, newAssociatedObjects, defaultAttributes)
          })
          .error(function(err) {
            emitter.emit('error', err)
@@ -155,20 +172,21 @@ module.exports = (function() {
      }).run()
    }
-    obj[this.accessors.add] = function(newAssociatedObject) {
+    obj[this.accessors.add] = function(newAssociatedObject, additionalAttributes) {
      var instance = this
        , primaryKeys = Object.keys(newAssociatedObject.daoFactory.primaryKeys || {})
        , primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : 'id'
        , where = {}
      where[newAssociatedObject.daoFactory.tableName+'.'+primaryKey] = newAssociatedObject[primaryKey]
      return new Utils.CustomEventEmitter(function(emitter) {
        instance[self.accessors.get]({ where: where })
          .error(function(err){ emitter.emit('error', err)})
          .success(function(currentAssociatedObjects) {
-            if (currentAssociatedObjects.length === 0) {
+            if (currentAssociatedObjects.length === 0 || self.customJoinTableModel === true) {
              var Class = self.connectorDAO ? HasManyMultiLinked : HasManySingleLinked
-              new Class(self, instance).injectAdder(emitter, newAssociatedObject)
+              new Class(self, instance).injectAdder(emitter, newAssociatedObject, additionalAttributes, !!currentAssociatedObjects.length)
            } else {
              emitter.emit('success', newAssociatedObject);
            }
@@ -183,8 +201,9 @@ module.exports = (function() {
          var newAssociations = []
          currentAssociatedObjects.forEach(function(association) {
-            if (!Utils._.isEqual(oldAssociatedObject.identifiers, association.identifiers))
+            if (!Utils._.isEqual(oldAssociatedObject.identifiers, association.identifiers)) {
              newAssociations.push(association)
+            }
          })
          instance[self.accessors.set](newAssociations)