Test and fix for ordering with belongsTo includes

lib/associations/belongs-to.js

@@ -10,24 +10,25 @@ module.exports = (function() {
     this.options              = options
     this.options              = options
     this.isSingleAssociation  = true
     this.isSingleAssociation  = true
     this.isSelfAssociation    = (this.source.tableName == this.target.tableName)
     this.isSelfAssociation    = (this.source.tableName == this.target.tableName)
+    this.as                   = this.options.as
 
 
-    if (this.isSelfAssociation && !this.options.foreignKey && !!this.options.as) {
-      this.options.foreignKey = Utils._.underscoredIf(Utils.singularize(this.options.as, this.source.options.language) + "Id", this.source.options.underscored)
+    if (this.isSelfAssociation && !this.options.foreignKey && !!this.as) {
+      this.options.foreignKey = Utils._.underscoredIf(Utils.singularize(this.as, this.source.options.language) + "Id", this.source.options.underscored)
     }
     }
 
 
-    if (!this.options.as) {
-      this.options.as = Utils.singularize(this.target.tableName, this.target.options.language)
+    if (!this.as) {
+      this.as = this.options.as = Utils.singularize(this.target.tableName, this.target.options.language)
     }
     }
 
 
     this.associationAccessor = this.isSelfAssociation
     this.associationAccessor = this.isSelfAssociation
-      ? Utils.combineTableNames(this.target.tableName, this.options.as)
-      : this.options.as
+      ? Utils.combineTableNames(this.target.tableName, this.as)
+      : this.as
 
 
     this.options.useHooks = options.useHooks
     this.options.useHooks = options.useHooks
 
 
     this.accessors = {
     this.accessors = {
-      get: Utils._.camelize('get_' + this.options.as),
-      set: Utils._.camelize('set_' + this.options.as)
+      get: Utils._.camelize('get_' + this.as),
+      set: Utils._.camelize('set_' + this.as)
     }
     }
   }
   }
 
 
@@ -37,7 +38,7 @@ module.exports = (function() {
       , targetKeys     = Object.keys(this.target.primaryKeys)
       , targetKeys     = Object.keys(this.target.primaryKeys)
       , keyType        = ((this.target.hasPrimaryKeys && targetKeys.length === 1) ? this.target.rawAttributes[targetKeys[0]].type : DataTypes.INTEGER)
       , keyType        = ((this.target.hasPrimaryKeys && targetKeys.length === 1) ? this.target.rawAttributes[targetKeys[0]].type : DataTypes.INTEGER)
 
 
-    this.identifier = this.options.foreignKey || Utils._.underscoredIf(Utils.singularize(this.target.tableName, this.target.options.language) + "Id", this.source.options.underscored)
+    this.identifier = this.options.foreignKey || Utils._.underscoredIf(this.as + "Id", this.source.options.underscored)
     newAttributes[this.identifier] = { type: this.options.keyType || keyType }
     newAttributes[this.identifier] = { type: this.options.keyType || keyType }
     Helpers.addForeignKeyConstraints(newAttributes[this.identifier], this.target, this.source, this.options)
     Helpers.addForeignKeyConstraints(newAttributes[this.identifier], this.target, this.source, this.options)
     Utils._.defaults(this.source.rawAttributes, newAttributes)
     Utils._.defaults(this.source.rawAttributes, newAttributes)

lib/dao-factory.js

@@ -1199,11 +1199,16 @@ module.exports = (function() {
   var validateIncludedElements = function(options) {
   var validateIncludedElements = function(options) {
     options.includeNames = []
     options.includeNames = []
     options.includeMap = {}
     options.includeMap = {}
+    options.hasSingleAssociation = false
+    options.hasMultiAssociation = false
     options.include = options.include.map(function(include) {
     options.include = options.include.map(function(include) {
       include = validateIncludedElement.call(this, include, options.daoFactory)
       include = validateIncludedElement.call(this, include, options.daoFactory)
+
+      if (include.association.isMultiAssociation) options.hasMultiAssociation = true
+      if (include.association.isSingleAssociation) options.hasSingleAssociation = true
+
       options.includeMap[include.as] = include
       options.includeMap[include.as] = include
       options.includeNames.push(include.as)
       options.includeNames.push(include.as)
-
       return include
       return include
     }.bind(this))
     }.bind(this))
   };
   };

lib/dialects/abstract/query-generator.js

@@ -437,7 +437,7 @@ module.exports = (function() {
         options.attributes = optAttributes.join(', ')
         options.attributes = optAttributes.join(', ')
       }
       }
 
 
-      var conditionalJoins = this.getConditionalJoins(options, factory),
+      var conditionalJoins = options.hasMultiAssociation && this.getConditionalJoins(options, factory),
         query;
         query;
 
 
       if (conditionalJoins) {
       if (conditionalJoins) {
@@ -626,12 +626,14 @@ module.exports = (function() {
       var associationParts = filterStr.split('.')
       var associationParts = filterStr.split('.')
         , attributePart = associationParts.pop()
         , attributePart = associationParts.pop()
         , self = this
         , self = this
+        , association
 
 
       associationParts.forEach(function (attribute) {
       associationParts.forEach(function (attribute) {
+        association = self.findAssociation(attribute, dao)
         dao = self.findAssociation(attribute, dao).target;
         dao = self.findAssociation(attribute, dao).target;
       })
       })
 
 
-      return dao.tableName + '.' +  attributePart;
+      return (association.as || association.options.as || dao.tableName) + '.' +  attributePart;
     },
     },
 
 
     getConditionalJoins: function(options, originalDao){
     getConditionalJoins: function(options, originalDao){

test/include.test.js

@@ -743,7 +743,7 @@ describe(Support.getTestDialectTeaser("Include"), function () {
       })
       })
     })
     })
 
 
-    xit('should support the order attribute on multiple associated entities', function(done) {
+    it('should support ordering with only belongsTo includes', function(done) {
       var User = this.sequelize.define('User', {})
       var User = this.sequelize.define('User', {})
         , Item = this.sequelize.define('Item', {'test': DataTypes.STRING})
         , Item = this.sequelize.define('Item', {'test': DataTypes.STRING})
         , Order = this.sequelize.define('Order', {'position': DataTypes.INTEGER})
         , Order = this.sequelize.define('Order', {'position': DataTypes.INTEGER})
@@ -751,8 +751,6 @@ describe(Support.getTestDialectTeaser("Include"), function () {
       User.belongsTo(Item, {'as': 'itemA'})
       User.belongsTo(Item, {'as': 'itemA'})
       User.belongsTo(Item, {'as': 'itemB'})
       User.belongsTo(Item, {'as': 'itemB'})
       User.belongsTo(Order)
       User.belongsTo(Order)
-        Item.hasMany(User)
-        Order.hasMany(User)
 
 
       this.sequelize.sync().done(function() {
       this.sequelize.sync().done(function() {
         async.auto({
         async.auto({
@@ -768,7 +766,7 @@ describe(Support.getTestDialectTeaser("Include"), function () {
               {'test': 'ghi'},
               {'test': 'ghi'},
               {'test': 'jkl'}
               {'test': 'jkl'}
             ]).done(function() {
             ]).done(function() {
-                Item.findAll().done(callback)
+              Item.findAll({order: ['id']}).done(callback)
             })
             })
           },
           },
           orders: function(callback) {
           orders: function(callback) {
@@ -777,7 +775,7 @@ describe(Support.getTestDialectTeaser("Include"), function () {
               {'position': 3},
               {'position': 3},
               {'position': 1}
               {'position': 1}
             ]).done(function() {
             ]).done(function() {
-                Order.findAll().done(callback)
+              Order.findAll({order: ['id']}).done(callback)
             })
             })
           },
           },
           associate: ['users', 'items', 'orders', function(callback, results) {
           associate: ['users', 'items', 'orders', function(callback, results) {
@@ -809,16 +807,24 @@ describe(Support.getTestDialectTeaser("Include"), function () {
             chainer.add(user3.setOrder(order1))
             chainer.add(user3.setOrder(order1))
 
 
             chainer.run().done(callback)
             chainer.run().done(callback)
-            }]}, function() {
-              User.findAll({'where': {'itemA.test': 'abc'}, 'include': [{'model': Item, 'as': 'itemA'}, {'model': Item, 'as': 'itemB'}, Order], 'order': 'order.position'}).done(function(err, as) {
+          }]
+        }, function() {
+          User.findAll({
+            'where': {'itemA.test': 'abc'}, 
+            'include': [
+              {'model': Item, 'as': 'itemA'},
+              {'model': Item, 'as': 'itemB'},
+              Order],
+            'order': ['Order.position']
+          }).done(function(err, as) {
             expect(err).not.to.be.ok
             expect(err).not.to.be.ok
             expect(as.length).to.eql(2)
             expect(as.length).to.eql(2)
 
 
-                expect(as[0].itemA[0].test).to.eql('abc')
-                expect(as[1].itemA[0].test).to.eql('abc')
+            expect(as[0].itemA.test).to.eql('abc')
+            expect(as[1].itemA.test).to.eql('abc')
 
 
             expect(as[0].order.position).to.eql(1)
             expect(as[0].order.position).to.eql(1)
-                expect(as[1].order.position).to.eql(3)
+            expect(as[1].order.position).to.eql(2)
 
 
             done()
             done()
           })
           })