add support for simple nested belongsTo -> hasMany include

lib/dialects/abstract/query.js

@@ -220,7 +220,7 @@ module.exports = (function() {
     // Queries with include
     // Queries with include
     } else if (this.options.hasJoin === true) {
     } else if (this.options.hasJoin === true) {
       results = groupJoinData(results, this.options)
       results = groupJoinData(results, this.options)
-      //console.log(JSON.stringify(results, null, '\t'));
+      console.log(JSON.stringify(results, null, '\t'));
       result = results.map(function(result) {
       result = results.map(function(result) {
         return this.callee.build(result, {
         return this.callee.build(result, {
           isNewRecord: false,
           isNewRecord: false,
@@ -328,7 +328,10 @@ module.exports = (function() {
       calleeData = _.omit(row, options.includeNames)
       calleeData = _.omit(row, options.includeNames)
 
 
       existingResult = _.find(results, function (result) {
       existingResult = _.find(results, function (result) {
-        return Utils._.isEqual(_.omit(result, options.includeNames), calleeData)
+        if (options.includeNames) {
+          return Utils._.isEqual(_.omit(result, options.includeNames.concat(['__children'])), calleeData)
+        }
+        return Utils._.isEqual(result, calleeData)
       })
       })
 
 
       if (!existingResult) {
       if (!existingResult) {
@@ -337,22 +340,22 @@ module.exports = (function() {
 
 
       for (var attrName in row) {
       for (var attrName in row) {
         if (row.hasOwnProperty(attrName)) {
         if (row.hasOwnProperty(attrName)) {
-          child = Object(row[attrName]) === row[attrName] && options.includeMap[attrName]
+          child = Object(row[attrName]) === row[attrName] && options.includeMap && options.includeMap[attrName]
           if (child) {
           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])
-              }
-            }
+            if (!existingResult.__children) existingResult.__children = {}
+            if (!existingResult.__children[attrName]) existingResult.__children[attrName] = [];
+
+            existingResult.__children[attrName].push(row[attrName])
           }
           }
         }
         }
-      }      
+      }
+    })
+
+    results.forEach(function (result) {
+      _.each(result.__children, function (children, key) {
+        result[key] = groupJoinData(children, options.includeMap[key])
+      })
+      delete result.__children
     })
     })
     return results
     return results
   }
   }

lib/dialects/postgres/query.js

@@ -142,10 +142,8 @@ module.exports = (function() {
             this.callee[key] = record
             this.callee[key] = record
           }
           }
         }
         }
-        this.emit('success', this.callee)
-      } else {
-        this.emit('success', rows)
-      }      
+      }  
+      this.emit('success', this.callee)    
     } else if (this.send('isUpdateQuery')) {
     } else if (this.send('isUpdateQuery')) {
       if(this.callee !== null) { // may happen for bulk updates
       if(this.callee !== null) { // may happen for bulk updates
         for (var key in rows[0]) {
         for (var key in rows[0]) {

lib/dialects/sqlite/query.js

@@ -89,7 +89,7 @@ module.exports = (function() {
   }
   }
 
 
   var onSuccess = function(results, metaData) {
   var onSuccess = function(results, metaData) {
-    var result = this.callee || results
+    var result = this.callee
 
 
     // add the inserted row id to the instance
     // add the inserted row id to the instance
     if (this.send('isInsertQuery', results, metaData)) {
     if (this.send('isInsertQuery', results, metaData)) {

test/include.test.js

@@ -161,7 +161,61 @@ describe(Support.getTestDialectTeaser("Include"), function () {
             user.tasks.forEach(function (task) {
             user.tasks.forEach(function (task) {
               expect(task.project).to.be.ok
               expect(task.project).to.be.ok
             })
             })
-            
+
+            done()
+          })
+        })
+      })
+    })
+
+    it('should support a simple nested belongsTo -> hasMany include', function (done) {
+      var Task = this.sequelize.define('Task', {})
+        , Worker = this.sequelize.define('Worker', {})
+        , Project = this.sequelize.define('Project', {})
+
+      Worker.belongsTo(Project)
+      Project.hasMany(Task)
+
+      this.sequelize.sync({force: true}).done(function () {
+        async.auto({
+          worker: function (callback) {
+            Worker.create().done(callback)
+          },
+          project: function (callback) {
+            Project.create().done(callback)
+          },
+          tasks: function(callback) {
+            Task.bulkCreate([
+              {},
+              {},
+              {},
+              {}
+            ]).done(function () {
+              Task.findAll().done(callback)
+            })
+          },
+          projectTasks: ['project', 'tasks', function (callback, results) {
+            results.project.setTasks(results.tasks).done(callback)
+          }],
+          projectWorker: ['project', 'worker', function (callback, results) {
+            results.worker.setProject(results.project).done(callback)
+          }]
+        }, function (err, results) {
+          Worker.find({
+            where: {
+              id: results.worker.id
+            },
+            include: [
+              {model: Project, include: [
+                {model: Task}
+              ]}
+            ]
+          }).done(function (err, worker) {
+            expect(err).not.to.be.ok
+            expect(worker.project).to.be.ok
+            expect(worker.project.tasks).to.be.ok
+            expect(worker.project.tasks.length).to.equal(4)
+
             done()
             done()
           })
           })
         })
         })