fix(findAll/deep-nested-includes): incorrect alias with `->` when subquery still…

… using `.` #7742 (#7795)

lib/dialects/abstract/query-generator.js

@@ -1457,7 +1457,7 @@ const QueryGenerator = {
         // The main model attributes is not aliased to a prefix
         // The main model attributes is not aliased to a prefix
         joinOn = `${this.quoteTable(parent.as || parent.model.name)}.${this.quoteIdentifier(attrLeft)}`;
         joinOn = `${this.quoteTable(parent.as || parent.model.name)}.${this.quoteIdentifier(attrLeft)}`;
       } else {
       } else {
-        joinOn = this.quoteIdentifier(`${asLeft}.${attrLeft}`);
+        joinOn = this.quoteIdentifier(`${asLeft.replace(/->/g, '.')}.${attrLeft}`);
       }
       }
     }
     }
 
 

test/integration/include/findAll.test.js

@@ -2053,5 +2053,49 @@ describe(Support.getTestDialectTeaser('Include'), () => {
           expect(posts[0].Entity.tags[0].EntityTag.entity_id).to.equal(posts[0].post_id);
           expect(posts[0].Entity.tags[0].EntityTag.entity_id).to.equal(posts[0].post_id);
         });
         });
     });
     });
+
+    it('should be able to generate a correct request with inner and outer join', function() {
+      const Customer = this.sequelize.define('customer', {
+        name: DataTypes.STRING
+      });
+
+      const ShippingAddress = this.sequelize.define('shippingAddress', {
+        address: DataTypes.STRING,
+        verified: DataTypes.BOOLEAN
+      });
+
+      const Order = this.sequelize.define('purchaseOrder', {
+        description: DataTypes.TEXT
+      });
+
+      const Shipment = this.sequelize.define('shipment', {
+        trackingNumber: DataTypes.STRING
+      });
+
+      Customer.hasMany(ShippingAddress);
+      ShippingAddress.belongsTo(Customer);
+
+      Customer.hasMany(Order);
+      Order.belongsTo(Customer);
+
+      Shipment.belongsTo(Order);
+      Order.hasOne(Shipment);
+
+      return this.sequelize.sync({ force: true }).then(() => {
+        return Shipment.findOne({
+          include: [{
+            model: Order,
+            required: true,
+            include: [{
+              model: Customer,
+              include: [{
+                model: ShippingAddress,
+                where: { verified: true }
+              }]
+            }]
+          }]
+        });
+      });
+    });
   });
   });
 });
 });

test/integration/model/find.test.js

@@ -549,13 +549,12 @@ describe(Support.getTestDialectTeaser('Model'), () => {
             });
             });
           });
           });
 
 
-          it(`throws an error indicating an incorrect alias was entered if an association
-              and alias exist but the alias doesn't match`, function() {
-              const self = this;
-              return self.Worker.findOne({ include: [{ model: self.Task, as: 'Work' }] }).catch (err => {
-                expect(err.message).to.equal('Task is associated to Worker using an alias. You\'ve included an alias (Work), but it does not match the alias defined in your association.');
-              });
+          it('throws an error indicating an incorrect alias was entered if an association and alias exist but the alias doesn\'t match', function() {
+            const self = this;
+            return self.Worker.findOne({ include: [{ model: self.Task, as: 'Work' }] }).catch (err => {
+              expect(err.message).to.equal('Task is associated to Worker using an alias. You\'ve included an alias (Work), but it does not match the alias defined in your association.');
             });
             });
+          });
 
 
           it('returns the associated task via worker.task', function() {
           it('returns the associated task via worker.task', function() {
             return this.Worker.findOne({
             return this.Worker.findOne({
@@ -711,13 +710,12 @@ describe(Support.getTestDialectTeaser('Model'), () => {
             });
             });
           });
           });
 
 
-          it(`throws an error indicating an incorrect alias was entered if an association
-              and alias exist but the alias doesn't match`, function() {
-              const self = this;
-              return self.Worker.findOne({ include: [{ model: self.Task, as: 'Work' }] }).catch (err => {
-                expect(err.message).to.equal('Task is associated to Worker using an alias. You\'ve included an alias (Work), but it does not match the alias defined in your association.');
-              });
+          it('throws an error indicating an incorrect alias was entered if an association and alias exist but the alias doesn\'t match', function() {
+            const self = this;
+            return self.Worker.findOne({ include: [{ model: self.Task, as: 'Work' }] }).catch (err => {
+              expect(err.message).to.equal('Task is associated to Worker using an alias. You\'ve included an alias (Work), but it does not match the alias defined in your association.');
             });
             });
+          });
 
 
           it('returns the associated task via worker.task', function() {
           it('returns the associated task via worker.task', function() {
             return this.Worker.findOne({
             return this.Worker.findOne({

test/integration/model/geography.test.js

@@ -157,8 +157,7 @@ describe(Support.getTestDialectTeaser('Model'), () => {
       it('should update a geography object', function() {
       it('should update a geography object', function() {
         const User = this.User;
         const User = this.User;
         const polygon1 = { type: 'Polygon', coordinates: [
         const polygon1 = { type: 'Polygon', coordinates: [
-            [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
-              [100.0, 1.0], [100.0, 0.0] ]
+            [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ]
           ]},
           ]},
           polygon2 = { type: 'Polygon', coordinates: [
           polygon2 = { type: 'Polygon', coordinates: [
             [ [100.0, 0.0], [102.0, 0.0], [102.0, 1.0],
             [ [100.0, 0.0], [102.0, 0.0], [102.0, 1.0],

test/integration/model/geometry.test.js

@@ -159,8 +159,7 @@ describe(Support.getTestDialectTeaser('Model'), () => {
       it('should update a geometry object', function() {
       it('should update a geometry object', function() {
         const User = this.User;
         const User = this.User;
         const polygon1 = { type: 'Polygon', coordinates: [
         const polygon1 = { type: 'Polygon', coordinates: [
-            [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
-              [100.0, 1.0], [100.0, 0.0] ]
+            [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ]
           ]},
           ]},
           polygon2 = { type: 'Polygon', coordinates: [
           polygon2 = { type: 'Polygon', coordinates: [
             [ [100.0, 0.0], [102.0, 0.0], [102.0, 1.0],
             [ [100.0, 0.0], [102.0, 0.0], [102.0, 1.0],

test/integration/transaction.test.js

@@ -417,34 +417,34 @@ if (current.dialect.supports.transactions) {
               Task.create({ title: 'Get rich', active: false}),
               Task.create({ title: 'Get rich', active: false}),
               (john, task1) => {
               (john, task1) => {
                 return john.setTasks([task1]);
                 return john.setTasks([task1]);
-              }).then(() => {
-              return self.sequelize.transaction(t1 => {
-
-                if (current.dialect.supports.lockOuterJoinFailure) {
-
-                  return expect(User.find({
-                    where: {
-                      username: 'John'
-                    },
-                    include: [Task],
-                    lock: t1.LOCK.UPDATE,
-                    transaction: t1
-                  })).to.be.rejectedWith('FOR UPDATE cannot be applied to the nullable side of an outer join');
-
-                } else {
-
-                  return User.find({
-                    where: {
-                      username: 'John'
-                    },
-                    include: [Task],
-                    lock: t1.LOCK.UPDATE,
-                    transaction: t1
-                  });
+              })
+              .then(() => {
+                return self.sequelize.transaction(t1 => {
+
+                  if (current.dialect.supports.lockOuterJoinFailure) {
+
+                    return expect(User.find({
+                      where: {
+                        username: 'John'
+                      },
+                      include: [Task],
+                      lock: t1.LOCK.UPDATE,
+                      transaction: t1
+                    })).to.be.rejectedWith('FOR UPDATE cannot be applied to the nullable side of an outer join');
 
 
-                }
+                  } else {
+
+                    return User.find({
+                      where: {
+                        username: 'John'
+                      },
+                      include: [Task],
+                      lock: t1.LOCK.UPDATE,
+                      transaction: t1
+                    });
+                  }
+                });
               });
               });
-            });
           });
           });
         });
         });
 
 
@@ -464,37 +464,38 @@ if (current.dialect.supports.transactions) {
                 Task.create({ title: 'Die trying', active: false}),
                 Task.create({ title: 'Die trying', active: false}),
                 (john, task1) => {
                 (john, task1) => {
                   return john.setTasks([task1]);
                   return john.setTasks([task1]);
-                }).then(() => {
-                return self.sequelize.transaction(t1 => {
-                  return User.find({
-                    where: {
-                      username: 'John'
-                    },
-                    include: [Task],
-                    lock: {
-                      level: t1.LOCK.UPDATE,
-                      of: User
-                    },
-                    transaction: t1
-                  }).then(t1John => {
-                  // should not be blocked by the lock of the other transaction
-                    return self.sequelize.transaction(t2 => {
-                      return Task.update({
-                        active: true
-                      }, {
-                        where: {
-                          active: false
-                        },
-                        transaction: t2
-                      });
-                    }).then(() => {
-                      return t1John.save({
-                        transaction: t1
+                })
+                .then(() => {
+                  return self.sequelize.transaction(t1 => {
+                    return User.find({
+                      where: {
+                        username: 'John'
+                      },
+                      include: [Task],
+                      lock: {
+                        level: t1.LOCK.UPDATE,
+                        of: User
+                      },
+                      transaction: t1
+                    }).then(t1John => {
+                    // should not be blocked by the lock of the other transaction
+                      return self.sequelize.transaction(t2 => {
+                        return Task.update({
+                          active: true
+                        }, {
+                          where: {
+                            active: false
+                          },
+                          transaction: t2
+                        });
+                      }).then(() => {
+                        return t1John.save({
+                          transaction: t1
+                        });
                       });
                       });
                     });
                     });
                   });
                   });
                 });
                 });
-              });
             });
             });
           });
           });
         }
         }