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

Author: grbsk

.travis.yml

@@ -1,7 +1,10 @@
 language: node_js
 
 node_js:
- - "6.1"
+ - "7"
+
+before_install:
+ - npm i -g npm@5
 
 install:
  - npm install

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

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];