allow additional options to be specified for associations

lib/annotations/ForeignKey.ts

@@ -1,10 +1,17 @@
+import {AssociationForeignKeyOptions} from 'sequelize';
 import {Model} from "../models/Model";
 import {addForeignKey} from "../services/association";
 
-export function ForeignKey(relatedClassGetter: () => typeof Model): Function {
+export function ForeignKey(relatedClassGetter: () => typeof Model, options?: AssociationForeignKeyOptions): Function {
 
   return (target: any, propertyName: string) => {
 
-    addForeignKey(target, relatedClassGetter, propertyName);
+    if (!options) {
+      options = {name: propertyName};
+    } else if (!options.name) {
+      options.name = propertyName;
+    }
+
+    addForeignKey(target, relatedClassGetter, options);
   };
 }

lib/annotations/association/BelongsTo.ts

@@ -1,17 +1,23 @@
+import {AssociationOptionsBelongsTo} from 'sequelize';
+
 import {Model} from "../../models/Model";
 import {BELONGS_TO, addAssociation} from "../../services/association";
 
 export function BelongsTo(relatedClassGetter: () => typeof Model,
-                          foreignKey?: string): Function {
+                          options?: string | AssociationOptionsBelongsTo): Function {
 
   return (target: any, propertyName: string) => {
 
+    if (typeof options === 'string') {
+      options = {foreignKey: {name: options}};
+    }
+
     addAssociation(
       target,
       BELONGS_TO,
       relatedClassGetter,
       propertyName,
-      foreignKey
+      options
     );
   };
 }

lib/annotations/association/BelongsToMany.ts

@@ -1,19 +1,24 @@
+import {AssociationOptionsBelongsToMany} from 'sequelize';
+
 import {Model} from "../../models/Model";
 import {BELONGS_TO_MANY, addAssociation} from "../../services/association";
 
 export function BelongsToMany(relatedClassGetter: () => typeof Model,
                               through: (() => typeof Model)|string,
-                              foreignKey?: string,
+                              options?: string | AssociationOptionsBelongsToMany,
                               otherKey?: string): Function {
 
   return (target: any, propertyName: string) => {
-
+    if (typeof options === 'string') {
+      // don't worry, through is mainly here to avoid TS error; actual through value is resolved later
+      options = {through: '', foreignKey: {name: options}};
+    }
     addAssociation(
       target,
       BELONGS_TO_MANY,
       relatedClassGetter,
       propertyName,
-      foreignKey,
+      options,
       otherKey,
       through
     );

lib/annotations/association/HasMany.ts

@@ -1,17 +1,21 @@
+import {AssociationOptionsHasMany} from 'sequelize';
+
 import {Model} from "../../models/Model";
 import {HAS_MANY, addAssociation} from "../../services/association";
 
 export function HasMany(relatedClassGetter: () => typeof Model,
-                        foreignKey?: string): Function {
+                        options?: string | AssociationOptionsHasMany): Function {
 
   return (target: any, propertyName: string) => {
-
+    if (typeof options === 'string') {
+      options = {foreignKey: {name: options}};
+    }
     addAssociation(
       target,
       HAS_MANY,
       relatedClassGetter,
       propertyName,
-      foreignKey
+      options
     );
   };
 }

lib/annotations/association/HasOne.ts

@@ -1,17 +1,21 @@
+import {AssociationOptionsHasOne} from 'sequelize';
+
 import {Model} from "../../models/Model";
 import {addAssociation, HAS_ONE} from "../../services/association";
 
 export function HasOne(relatedClassGetter: () => typeof Model,
-                       foreignKey?: string): Function {
+                       options?: string | AssociationOptionsHasOne): Function {
 
   return (target: any, propertyName: string) => {
-
+    if (typeof options === 'string') {
+      options = {foreignKey: {name: options}};
+    }
     addAssociation(
       target,
       HAS_ONE,
       relatedClassGetter,
       propertyName,
-      foreignKey
+      options
     );
   };
 }

lib/interfaces/ISequelizeAssociation.ts

@@ -1,3 +1,5 @@
+import {AssociationOptionsBelongsTo, AssociationOptionsBelongsToMany, AssociationOptionsHasMany,
+  AssociationOptionsHasOne, AssociationOptionsManyToMany} from 'sequelize';
 import {Model} from "../models/Model";
 
 export interface ISequelizeAssociation {
@@ -6,7 +8,8 @@ export interface ISequelizeAssociation {
   relatedClassGetter: () => typeof Model;
   through?: string;
   throughClassGetter?: () => typeof Model;
-  foreignKey?: string;
+  options?: AssociationOptionsBelongsTo | AssociationOptionsBelongsToMany | AssociationOptionsHasMany |
+    AssociationOptionsHasOne | AssociationOptionsManyToMany;
   otherKey?: string;
   as: string;
 }

lib/interfaces/ISequelizeForeignKeyConfig.ts

@@ -1,7 +1,8 @@
+import {AssociationForeignKeyOptions} from 'sequelize';
 import {Model} from "../models/Model";
 
 export interface ISequelizeForeignKeyConfig {
 
   relatedClassGetter: () => typeof Model;
-  foreignKey: string;  
+  options: string | AssociationForeignKeyOptions;
 }

lib/models/BaseSequelize.ts

@@ -1,3 +1,4 @@
+import {merge} from 'lodash';
 import {Model} from "./Model";
 import {getModels} from "../services/models";
 import {getAssociations, BELONGS_TO_MANY} from "../services/association";
@@ -89,7 +90,6 @@ export abstract class BaseSequelize {
 
       associations.forEach(association => {
 
-        const foreignKey = association.foreignKey || getForeignKey(model, association);
         const relatedClass = association.relatedClassGetter();
         let through;
         let otherKey;
@@ -126,12 +126,17 @@ export abstract class BaseSequelize {
           }
         }
 
-        model[association.relation](relatedClass, {
+        // ensure association options by default have most explicit foreignKey options
+        // so it merges properly with different foreignKey option permutations, or is overrwritten
+        // completely by options.foreignKey
+        const foreignKey = getForeignKey(model, association);
+        const options =  merge({foreignKey: {name: foreignKey}}, association.options,
+        {
           as: association.as,
           through,
-          foreignKey,
           otherKey
         });
+        model[association.relation](relatedClass, options);
 
         // The associations has to be adjusted
         const _association = model['associations'][association.as];

lib/services/association.ts

@@ -1,4 +1,6 @@
 import 'reflect-metadata';
+import {AssociationOptions, AssociationForeignKeyOptions, AssociationOptionsBelongsTo, AssociationOptionsBelongsToMany,
+   AssociationOptionsHasMany, AssociationOptionsHasOne, AssociationOptionsManyToMany} from 'sequelize';
 import {Model} from "../models/Model";
 import {ISequelizeForeignKeyConfig} from "../interfaces/ISequelizeForeignKeyConfig";
 import {ISequelizeAssociation} from "../interfaces/ISequelizeAssociation";
@@ -18,7 +20,9 @@ export function addAssociation(target: any,
                                relation: string,
                                relatedClassGetter: () => typeof Model,
                                as: string,
-                               foreignKey?: string,
+                               options?: AssociationOptionsBelongsTo |
+                                 AssociationOptionsBelongsToMany | AssociationOptionsHasMany |
+                                 AssociationOptionsHasOne | AssociationOptionsManyToMany,
                                otherKey?: string,
                                through?: (() => typeof Model)|string): void {
 
@@ -42,7 +46,7 @@ export function addAssociation(target: any,
     throughClassGetter,
     through: through as string,
     as,
-    foreignKey,
+    options,
     otherKey
   });
 }
@@ -52,11 +56,19 @@ export function addAssociation(target: any,
  */
 export function getForeignKey(_class: typeof Model,
                               association: ISequelizeAssociation): string {
+  const options = association.options as AssociationOptions;
 
-  // if foreign key is defined return this one
-  if (association.foreignKey) {
+  if (options && options.foreignKey) {
+    const foreignKey = options.foreignKey;
+    // if options is an object and has a string foreignKey property, use that as the name
+    if (typeof foreignKey === 'string') {
+      return foreignKey;
+    }
 
-    return association.foreignKey;
+    // if options is an object with foreignKey.name, use that as the name
+    if (foreignKey.name) {
+      return foreignKey.name;
+    }
   }
 
   // otherwise calculate the foreign key by related or through class
@@ -90,8 +102,10 @@ export function getForeignKey(_class: typeof Model,
   for (const foreignKey of foreignKeys) {
 
     if (foreignKey.relatedClassGetter() === relatedClass) {
-
-      return foreignKey.foreignKey;
+      if (typeof foreignKey.options === 'string') {
+        return foreignKey.options;
+      }
+      return (foreignKey.options as any).name;
     }
   }
 
@@ -123,7 +137,7 @@ export function getAssociationsByRelation(target: any, relatedClass: any): ISequ
  */
 export function addForeignKey(target: any,
                               relatedClassGetter: () => typeof Model,
-                              attrName: string): void {
+                              options: string | AssociationForeignKeyOptions): void {
 
   let foreignKeys = getForeignKeys(target);
 
@@ -134,7 +148,7 @@ export function addForeignKey(target: any,
 
   foreignKeys.push({
     relatedClassGetter,
-    foreignKey: attrName
+    options
   });
 }