Make groupJoinData able to handle nested belongsTo (naive implementation, will b…

…reak on multiple objects for sure)

lib/dao-factory.js

@@ -376,9 +376,7 @@ module.exports = (function() {
       if (options.hasOwnProperty('include')) {
         hasJoin = true
 
-        options.include = options.include.map(function(include) {
-          return validateIncludedElement.call(this, include)
-        }.bind(this))
+        validateIncludedElements.call(this, options)
       }
 
       // whereCollection is used for non-primary key updates
@@ -461,9 +459,7 @@ module.exports = (function() {
       if (options.hasOwnProperty('include')) {
         hasJoin = true
 
-        options.include = options.include.map(function(include) {
-          return validateIncludedElement.call(this, include)
-        }.bind(this))
+        validateIncludedElements.call(this, options)
       }
 
       // whereCollection is used for non-primary key updates
@@ -1194,6 +1190,18 @@ module.exports = (function() {
     }.bind(this))
   }
 
+  var validateIncludedElements = function(options) {
+    options.includeNames = []
+    options.includeMap = {}
+    options.include = options.include.map(function(include) {
+      include = validateIncludedElement.call(this, include, options.daoFactory)
+      options.includeMap[include.as] = include
+      options.includeNames.push(include.as)
+
+      return include
+    }.bind(this))
+  };
+
   var validateIncludedElement = function(include, parent) {
     if (include instanceof DAOFactory) {
       include = { daoFactory: include, as: include.tableName }
@@ -1242,9 +1250,10 @@ module.exports = (function() {
           include.association = association
 
           if (include.hasOwnProperty('include')) {
-            include.include = include.include.map(function(childInclude) {
+            /*include.include = include.include.map(function(childInclude) {
               return validateIncludedElement.call(this, childInclude, include.daoFactory)
-            }.bind(this))
+            }.bind(this))*/
+            validateIncludedElements(include)
           }
 
           return include

lib/dialects/abstract/query.js

@@ -219,16 +219,15 @@ module.exports = (function() {
 
     // Queries with include
     } else if (this.options.hasJoin === true) {
-      this.options.includeNames = this.options.include.map(function (include) {
-          return include.as
-      })
-      results = groupJoinData.call(this, results)
+      results = groupJoinData(results, this.options)
+      //console.log(JSON.stringify(results, null, '\t'));
       result = results.map(function(result) {
         return this.callee.build(result, {
           isNewRecord: false,
           isDirty: false,
           include:this.options.include,
           includeNames: this.options.includeNames,
+          includeMap: this.options.includeMap,
           includeValidated: true
         })
       }.bind(this))
@@ -318,18 +317,18 @@ module.exports = (function() {
       ]
   */
 
-  var groupJoinData = function(data) {
-    var self = this
-      , results = []
+  var groupJoinData = function(data, options) {
+    var results = []
       , existingResult
       , calleeData
+      , child
 
     data.forEach(function (row) {
       row = Dot.transform(row)
-      calleeData = _.omit(row, self.options.includeNames)
+      calleeData = _.omit(row, options.includeNames)
 
       existingResult = _.find(results, function (result) {
-        return Utils._.isEqual(_.omit(result, self.options.includeNames), calleeData)
+        return Utils._.isEqual(_.omit(result, options.includeNames), calleeData)
       })
 
       if (!existingResult) {
@@ -337,16 +336,23 @@ module.exports = (function() {
       }
 
       for (var attrName in row) {
-        if (row.hasOwnProperty(attrName) && Object(row[attrName]) === row[attrName] && self.options.includeNames.indexOf(attrName) !== -1) {
+        if (row.hasOwnProperty(attrName)) {
+          child = Object(row[attrName]) === row[attrName] && options.includeMap[attrName]
+          if (child) {
             existingResult[attrName] = existingResult[attrName] || []
             var attrRowExists = existingResult[attrName].some(function(attrRow) {
               return Utils._.isEqual(attrRow, row[attrName])
             })
             if (!attrRowExists) {
+              if (child.include) {
+                existingResult[attrName].push(groupJoinData([row[attrName]], child)[0])
+              } else {
                 existingResult[attrName].push(row[attrName])
               }
             }
           }
+        }
+      }      
     })
     return results
   }

lib/query-interface.js

@@ -659,7 +659,7 @@ module.exports = (function() {
     }
 
     var sql = this.QueryGenerator.selectQuery(tableName, options, factory)
-    queryOptions = Utils._.extend({}, queryOptions, { include: options.include })
+    queryOptions = Utils._.extend({}, queryOptions, { include: options.include, includeNames: options.includeNames, includeMap: options.includeMap })
 
     return queryAndEmit.call(this, [sql, factory, queryOptions], 'select')
   }

test/include.test.js

@@ -25,7 +25,7 @@ describe(Support.getTestDialectTeaser("Include"), function () {
     Task.belongsTo(User)
     User.belongsTo(Group)
 
-    this.sequelize.sync().then(function () {
+    this.sequelize.sync({force: true}).done(function () {
       async.auto({
         task: function (callback) {
           Task.create().done(callback)
@@ -53,8 +53,12 @@ describe(Support.getTestDialectTeaser("Include"), function () {
             ]}
           ]
         }).done(function (err, task) {
+          console.log(err && err.sql)
+          expect(err).not.to.be.ok
           expect(task.user).to.be.ok
           expect(task.user.group).to.be.ok
+        }).on('sql', function (sql) {
+          console.log(sql)
         })
       })
     })