allow additional options to be specified for associations

fixes sequelize#34

Author: grbsk

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
  });
 }