Merge branch 'master' into feature/update-docs-associations

grbsk · grbsk · commit 8bae584eb35a · 2017-07-06T14:38:50.000-04:00
diff --git a/.travis.yml b/.travis.yml
@@ -1,7 +1,10 @@
 language: node_js
 
 node_js:
-  - "6.1"
+  - "7"
+
+before_install:
+  - npm i -g npm@5
 
 install:
   - npm install
diff --git a/README.md b/README.md
@@ -65,7 +65,7 @@ should appear as a column in the database, require the `@Column` annotation.
  
 ### `@Table`
 The `@Table` annotation can be used without passing any parameters. To specify some more define options, use
-an object literal (all [define options](http://docs.sequelizejs.com/en/v3/api/sequelize/#definemodelname-attributes-options-model) 
+an object literal (all [define options](http://docs.sequelizejs.com/manual/tutorial/models-definition.html#configuration) 
 from sequelize are valid):
 ```typescript
 @Table({
@@ -79,7 +79,7 @@ class Person extends Model<Person> {}
 Decorator                             | Description
 --------------------------------------|---------------------
  `@Table`                             | sets `options.tableName=<CLASS_NAME>` and  `options.modelName=<CLASS_NAME>` automatically
- `@Table(options: DefineOptions)`     | sets [define options](http://docs.sequelizejs.com/en/v3/api/sequelize/#definemodelname-attributes-options-model) (also sets `options.tableName=<CLASS_NAME>` and  `options.modelName=<CLASS_NAME>` if not already defined by define options) 
+ `@Table(options: DefineOptions)`     | sets [define options](http://docs.sequelizejs.com/manual/tutorial/models-definition.html#configuration) (also sets `options.tableName=<CLASS_NAME>` and  `options.modelName=<CLASS_NAME>` if not already defined by define options) 
 
 #### Primary key
 A primary key (`id`) will be inherited from base class `Model`. This primary key is by default an `INTEGER` and has 
@@ -124,7 +124,7 @@ import {DataType} from 'sequelize-typescript';
   name: string;
 ```
 Or for a more detailed column description, use an object literal 
-(all [attribute options](http://docs.sequelizejs.com/en/v3/api/sequelize/#definemodelname-attributes-options-model) 
+(all [attribute options](http://docs.sequelizejs.com/manual/tutorial/models-definition.html#configuration) 
 from sequelize are valid):
 ```typescript
   @Column({
@@ -138,9 +138,9 @@ from sequelize are valid):
 
 Decorator                             | Description
 --------------------------------------|---------------------
- `@Column`                            | tries to infer [dataType](http://docs.sequelizejs.com/en/v3/docs/models-definition/#data-types) from js type
- `@Column(dataType: DateType)`        | sets [dataType](http://docs.sequelizejs.com/en/v3/docs/models-definition/#data-types) explicitly
- `@Column(options: AttributeOptions)` | sets [attribute options](http://docs.sequelizejs.com/en/v3/api/sequelize/#definemodelname-attributes-options-model)
+ `@Column`                            | tries to infer [dataType](http://docs.sequelizejs.com/manual/tutorial/models-definition.html#data-types) from js type
+ `@Column(dataType: DateType)`        | sets [dataType](http://docs.sequelizejs.com/manual/tutorial/models-definition.html#data-types) explicitly
+ `@Column(options: AttributeOptions)` | sets [attribute options](http://docs.sequelizejs.com/manual/tutorial/models-definition.html#configuration)
 
 #### *Shortcuts*
 If you're in love with decorators: *sequelize-typescript* provides some more of them. The following decorators can be 
@@ -185,7 +185,7 @@ class Person extends Model<Person> {
  
 ## Usage
 Except for minor variations *sequelize-typescript* will work like pure sequelize. 
-(See sequelize [docs](http://docs.sequelizejs.com/en/v3/docs/models-usage/))
+(See sequelize [docs](http://docs.sequelizejs.com/manual/tutorial/models-usage.html))
 ### Configuration
 To make the defined models available, you have to configure a `Sequelize` instance from `sequelize-typescript`(!). 
 ```typescript
@@ -233,7 +233,7 @@ person.save();
 
 ### Find and update
 Finding and updating entries do also work like using native sequelize. So see sequelize 
-[docs](http://docs.sequelizejs.com/en/v3/docs/models-usage/) for more details.
+[docs](http://docs.sequelizejs.com/manual/tutorial/models-usage.html) for more details.
 ```typescript
 Person
  .findOne<Person>()
@@ -444,7 +444,7 @@ validation instead, you can do so by simply adding the validate options *as* dec
 So that `validate.isEmail=true` becomes `@IsEmail`, `validate.equals='value'` becomes `@Equals('value')` 
 and so on. Please notice, that a validator, that expects a boolean, is translated to an annotation without a parameter. 
 
-See sequelize [docs](http://docs.sequelizejs.com/en/v3/docs/models-definition/#validations) 
+See sequelize [docs](http://docs.sequelizejs.com/manual/tutorial/models-definition.html#validations) 
 for all validators.
 
 ### Exceptions
@@ -514,7 +514,7 @@ export class Shoe extends Model<Shoe> {
 Scopes can be defined with annotations as well. The scope options are mostly the same like in native
 sequelize except of the way how model classes are referenced. So instead of referencing them directly a getter
 function `() => Model` is used instead. 
-(See sequelize [docs](http://docs.sequelizejs.com/en/v3/docs/scopes/) for more details)
+(See sequelize [docs](http://docs.sequelizejs.com/manual/tutorial/scopes.html) for more details)
 
 ### `@DefaultScope` and `@Scopes`
 ```typescript
diff --git a/lib/annotations/ForeignKey.ts b/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);
   };
 }
diff --git a/lib/annotations/association/BelongsTo.ts b/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
     );
   };
 }
diff --git a/lib/annotations/association/BelongsToMany.ts b/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
     );
diff --git a/lib/annotations/association/HasMany.ts b/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
     );
   };
 }
diff --git a/lib/annotations/association/HasOne.ts b/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
     );
   };
 }
diff --git a/lib/interfaces/ISequelizeAssociation.ts b/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;
 }
diff --git a/lib/interfaces/ISequelizeForeignKeyConfig.ts b/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;
 }
diff --git a/lib/models/BaseSequelize.ts b/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];
diff --git a/lib/services/association.ts b/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
   });
 }
 
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "sequelize-typescript",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Decorators and some other extras for sequelize (v3 + v4)",
   "scripts": {
     "build": "tsc --project lib/models/v4 && tsc",
diff --git a/test/specs/association.spec.ts b/test/specs/association.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,8 @@`
	`1`	`+import {AssociationForeignKeyOptions} from 'sequelize';`
`1`	`2`	`import {Model} from "../models/Model";`
`2`	`3`
`3`	`4`	`export interface ISequelizeForeignKeyConfig {`
`4`	`5`
`5`	`6`	`relatedClassGetter: () => typeof Model;`
`6`		`- foreignKey: string;`
	`7`	`+ options: string \| AssociationForeignKeyOptions;`
`7`	`8`	`}`