Enable association compatibility with Sequelize

README.md

@@ -563,6 +563,49 @@ explicitly:
   proofedBooks: Book[];
 ```
 
+### Multiple relations of same models and sequelize aliasing compatibility
+
+When defining a relationship, _sequelize_ allows you to configure an alias, but it also allows you to configure empty aliases
+as a sort of default relationship when querying. When using _sequelize-typescript_, it defaults to add an alias.
+
+Consider the following model definition:
+
+```typescript
+@Table
+class User extends Model {
+  @HasMany(() => Comment)
+  comments: Comment[];
+
+  @HasMany(() => Comment, {
+    as: 'archivedComments'
+  })
+  archivedComments: Comment[];
+}
+```
+
+Running the following query will result in an error:
+
+```typescript
+User.findOne({ include: [Comment, 'archivedComments'] })
+// Error: Alias cannot be inferred: "user" has multiple relations with "comment"
+```
+
+To revert to the original _sequelize_ behavior, you can turn off the automatic aliasing by specifying `undefined` for
+the alias value:
+
+```typescript
+@Table({ modelName: 'user' })
+class User extends Model {
+  @HasMany(() => Comment, { as: undefined })
+  comments: Comment[];
+
+  @HasMany(() => Comment, {
+    as: 'archivedComments'
+  })
+  archivedComments: Comment[];
+}
+```
+
 ### Type safe usage of auto generated functions
 
 With the creation of a relation, sequelize generates some method on the corresponding

src/associations/alias-inference/alias-inference-service.ts

@@ -1,5 +1,18 @@
+import { BaseAssociation } from '../shared/base-association';
 import { getAssociationsByRelation } from '../shared/association-service';
 
+/**
+ * Returns true if automatic association is possible given include parameters and list of associations
+ */
+function automaticAssociationInferrencePossible<TCreationAttributes, TModelAttributes>(
+  include: { model: any; as: any },
+  associations: BaseAssociation<TCreationAttributes, TModelAttributes>[]
+): boolean {
+  const hasModelOptionWithoutAsOption = !!(include.model && !include.as);
+  const associationsWithoutAs = associations.filter((assoc) => !assoc.getAs());
+  return associationsWithoutAs.length === 1 && hasModelOptionWithoutAsOption;
+}
+
 /**
  * Pre conform includes, so that "as" value can be inferred from source
  */
@@ -44,7 +57,9 @@ function inferAliasForInclude(include: any, source: any): any {
     const relatedClass = include.model;
     const associations = getAssociationsByRelation(targetPrototype, relatedClass);
 
-    if (associations.length > 0) {
+    if (automaticAssociationInferrencePossible(include, associations)) {
+      // Do nothing, this "include" is actually fine
+    } else if (associations.length > 0) {
       if (associations.length > 1) {
         throw new Error(
           `Alias cannot be inferred: "${source.name}" has multiple ` +

src/associations/belongs-to-many/belongs-to-many.ts

@@ -48,7 +48,7 @@ export function BelongsToMany<
       options = { ...throughOrOptions };
     }
 
-    if (!options.as) options.as = propertyName;
+    if (!options.as && !('as' in options)) options.as = propertyName;
 
     addAssociation(
       target,

src/associations/belongs-to/belongs-to.ts

@@ -20,7 +20,7 @@ export function BelongsTo<TCreationAttributes extends {}, TModelAttributes exten
 ): Function {
   return (target: any, propertyName: string) => {
     const options: BelongsToOptions = getPreparedAssociationOptions(optionsOrForeignKey);
-    if (!options.as) options.as = propertyName;
+    if (!options.as && !('as' in options)) options.as = propertyName;
     addAssociation(target, new BelongsToAssociation(associatedClassGetter, options));
   };
 }

src/associations/has/has-many.ts

@@ -21,7 +21,7 @@ export function HasMany<TCreationAttributes extends {}, TModelAttributes extends
 ): Function {
   return (target: any, propertyName: string) => {
     const options: HasManyOptions = getPreparedAssociationOptions(optionsOrForeignKey);
-    if (!options.as) options.as = propertyName;
+    if (!options.as && !('as' in options)) options.as = propertyName;
     addAssociation(target, new HasAssociation(associatedClassGetter, options, Association.HasMany));
   };
 }

src/associations/has/has-one.ts

@@ -21,7 +21,7 @@ export function HasOne<TCreationAttributes extends {}, TModelAttributes extends
 ): Function {
   return (target: any, propertyName: string) => {
     const options: HasOneOptions = getPreparedAssociationOptions(optionsOrForeignKey);
-    if (!options.as) options.as = propertyName;
+    if (!options.as && !('as' in options)) options.as = propertyName;
     addAssociation(target, new HasAssociation(associatedClassGetter, options, Association.HasOne));
   };
 }

test/specs/annotations/belongs-to-many.spec.ts

@@ -14,6 +14,9 @@ describe('BelongsToMany', () => {
   @Table
   class Team extends Model {}
 
+  @Table
+  class Rank extends Model {}
+
   @Table
   class Player extends Model {
     @BelongsToMany(() => Team, {
@@ -23,11 +26,23 @@ describe('BelongsToMany', () => {
       otherKey: 'teamId',
     })
     teams: Team[];
+
+    @BelongsToMany(() => Rank, {
+      as: undefined,
+      through: 'RankPlayer',
+      foreignKey: 'playerId',
+      otherKey: 'rankId',
+    })
+    Ranks: Rank[];
   }
 
-  sequelize.addModels([Team, Player]);
+  sequelize.addModels([Team, Player, Rank]);
 
   it('should pass as options to sequelize association', () => {
     expect(Player['associations']).to.have.property(as);
   });
+
+  it('should use association model name if passed undefined for "as"', () => {
+    expect(Player['associations']).to.have.property('Ranks');
+  });
 });

test/specs/annotations/belongs-to.spec.ts

@@ -14,18 +14,28 @@ describe('BelongsTo', () => {
   @Table
   class Team extends Model {}
 
+  @Table
+  class Rank extends Model {}
+
   @Table
   class Player extends Model {
     @BelongsTo(() => Team, { as, foreignKey: 'teamId' })
     team: Team;
+
+    @BelongsTo(() => Rank, { as: undefined, foreignKey: 'rankId' })
+    Rank: Rank;
   }
 
-  sequelize.addModels([Team, Player]);
+  sequelize.addModels([Team, Player, Rank]);
 
   it('should pass as options to sequelize association', () => {
     expect(Player['associations']).to.have.property(as);
   });
 
+  it('should use association model name if passed undefined for "as"', () => {
+    expect(Player['associations']).to.have.property('Rank');
+  });
+
   it('should throw due to missing foreignKey', () => {
     const _sequelize = createSequelize(false);
 

test/specs/annotations/has-many.spec.ts

@@ -14,18 +14,31 @@ describe('HasMany', () => {
   @Table
   class Player extends Model {}
 
+  @Table
+  class Rank extends Model {}
+
   @Table
   class Team extends Model {
     @HasMany(() => Player, {
       as,
       foreignKey: 'teamId',
     })
     players: Player[];
+
+    @HasMany(() => Rank, {
+      as: undefined,
+      foreignKey: 'rankId',
+    })
+    Ranks: Rank[];
   }
 
-  sequelize.addModels([Team, Player]);
+  sequelize.addModels([Team, Player, Rank]);
 
   it('should pass as options to sequelize association', () => {
     expect(Team['associations']).to.have.property(as);
   });
+
+  it('should use association model name if passed undefined for "as"', () => {
+    expect(Team['associations']).to.have.property('Ranks');
+  });
 });

test/specs/annotations/has-one.spec.ts

@@ -14,18 +14,31 @@ describe('HasOne', () => {
   @Table
   class Player extends Model {}
 
+  @Table
+  class Rank extends Model {}
+
   @Table
   class Team extends Model {
     @HasOne(() => Player, {
       as,
       foreignKey: 'teamId',
     })
     player: Player;
+
+    @HasOne(() => Rank, {
+      as: undefined,
+      foreignKey: 'rankId',
+    })
+    Rank: Rank;
   }
 
-  sequelize.addModels([Team, Player]);
+  sequelize.addModels([Team, Player, Rank]);
 
   it('should pass as options to sequelize association', () => {
     expect(Team['associations']).to.have.property(as);
   });
+
+  it('should use association model name if passed undefined for "as"', () => {
+    expect(Player['associations']).to.have.property('Rank');
+  });
 });