Merge pull request #48 from RobinBuschmann/refactoring-1

Refactoring part 1

Author: RobinBuschmann

example/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "module": "commonjs",
-    "target": "es5",
+    "target": "es6",
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "sourceMap": true,

lib/annotations/ForeignKey.ts

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

lib/annotations/association/BelongsTo.ts

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

lib/annotations/association/BelongsToMany.ts

@@ -1,26 +1,36 @@
-import {AssociationOptionsBelongsToMany} from 'sequelize';
-
-import {Model} from "../../models/Model";
 import {BELONGS_TO_MANY, addAssociation} from "../../services/association";
+import {ModelClassGetter} from "../../types/ModelClassGetter";
+import {IAssociationOptionsBelongsToMany} from "../../interfaces/IAssociationOptionsBelongsToMany";
 
-export function BelongsToMany(relatedClassGetter: () => typeof Model,
-                              through: (() => typeof Model)|string,
-                              options?: string | AssociationOptionsBelongsToMany,
+export function BelongsToMany(relatedClassGetter: ModelClassGetter,
+                              through: (ModelClassGetter) | string,
+                              foreignKey?: string,
+                              otherKey?: string): Function;
+export function BelongsToMany(relatedClassGetter: ModelClassGetter,
+                              options: IAssociationOptionsBelongsToMany): Function;
+export function BelongsToMany(relatedClassGetter: ModelClassGetter,
+                              throughOrOptions: (ModelClassGetter | string) | IAssociationOptionsBelongsToMany,
+                              foreignKey?: string,
                               otherKey?: string): Function {
+  const typeOfThroughOrOptions = typeof throughOrOptions;
+  let through;
+  let options: Partial<IAssociationOptionsBelongsToMany>;
 
+  if (typeOfThroughOrOptions === 'string' || typeOfThroughOrOptions === 'function') {
+    through = throughOrOptions;
+  } else {
+    through = (throughOrOptions as IAssociationOptionsBelongsToMany).through;
+    options = throughOrOptions;
+  }
   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,
-      options,
+      options || foreignKey,
+      through,
       otherKey,
-      through
     );
   };
 }

lib/annotations/association/HasMany.ts

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

lib/annotations/association/HasOne.ts

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

lib/interfaces/IAssociationOptionsBelongsToMany.ts

@@ -0,0 +1,7 @@
+import {AssociationForeignKeyOptions, AssociationOptionsManyToMany} from "sequelize";
+import {ModelClassGetter} from "../types/ModelClassGetter";
+
+export interface IAssociationOptionsBelongsToMany extends AssociationOptionsManyToMany {
+  through: ModelClassGetter | string;
+  otherKey?: string | AssociationForeignKeyOptions;
+}

lib/interfaces/IScopeFindOptions.ts

@@ -1,7 +1,7 @@
 import {WhereOptions, LoggingOptions, SearchPathOptions, col, and, or, FindOptionsAttributesArray,
   literal} from 'sequelize';
-import {Model} from "../models/Model";
 import {IScopeIncludeOptions} from "./IScopeIncludeOptions";
+import {ModelClassGetter} from "../types/ModelClassGetter";
 
 /* tslint:disable:array-type */
 /* tslint:disable:max-line-length */
@@ -33,16 +33,16 @@ export interface IScopeFindOptions extends LoggingOptions, SearchPathOptions {
    * If your association are set up with an `as` (eg. `X.hasMany(Y, { as: 'Z }`, you need to specify Z in
    * the as attribute when eager loading Y).
    */
-  include?: Array<(() => typeof Model) | IScopeIncludeOptions>;
+  include?: Array<ModelClassGetter | IScopeIncludeOptions>;
 
   /**
    * Specifies an ordering. If a string is provided, it will be escaped. Using an array, you can provide
    * several columns / functions to order by. Each element can be further wrapped in a two-element array. The
    * first element is the column / function to order by, the second is the direction. For example:
    * `order: [['name', 'DESC']]`. In this way the column will be escaped, but the direction will not.
    */
-  order?: string | col | literal | Array<string | number | (() => typeof Model) | { model: (() => typeof Model), as?: string }> |
-    Array<string | col | literal | Array<string | number | (() => typeof Model) | { model: (() => typeof Model), as?: string }>>;
+  order?: string | col | literal | Array<string | number | ModelClassGetter | { model: ModelClassGetter, as?: string }> |
+    Array<string | col | literal | Array<string | number | ModelClassGetter | { model: ModelClassGetter, as?: string }>>;
 
   /**
    * Limit the results
@@ -59,7 +59,7 @@ export interface IScopeFindOptions extends LoggingOptions, SearchPathOptions {
    * Postgres also supports transaction.LOCK.KEY_SHARE, transaction.LOCK.NO_KEY_UPDATE and specific model
    * locks with joins. See [transaction.LOCK for an example](transaction#lock)
    */
-  lock?: string | { level: string, of: (() => typeof Model) };
+  lock?: string | { level: string, of: ModelClassGetter };
 
   /**
    * Return raw result. See sequelize.query for more information.

lib/interfaces/IScopeIncludeAssociation.ts

@@ -1,10 +1,9 @@
-import {Model} from "../models/Model";
-
+import {ModelClassGetter} from "../types/ModelClassGetter";
 /**
  * Association Object for Include Options
  */
 export interface IScopeIncludeAssociation {
-  source: (() => typeof Model);
-  target: (() => typeof Model);
+  source: ModelClassGetter;
+  target: ModelClassGetter;
   identifier: string;
 }

lib/interfaces/IScopeIncludeOptions.ts

@@ -1,6 +1,6 @@
 import {WhereOptions, IncludeThroughOptions} from 'sequelize';
-import {Model} from "../models/Model";
 import {IScopeIncludeAssociation} from "./IScopeIncludeAssociation";
+import {ModelClassGetter} from "../types/ModelClassGetter";
 
 /**
  * Complex include options
@@ -10,7 +10,7 @@ export interface IScopeIncludeOptions {
   /**
    * The model you want to eagerly load
    */
-  model?: (() => typeof Model);
+  model?: ModelClassGetter;
 
   /**
    * The alias of the relation, in case the model you want to eagerly load is aliassed. For `hasOne` /
@@ -48,6 +48,6 @@ export interface IScopeIncludeOptions {
   /**
    * Load further nested related models
    */
-  include?: Array<(() => typeof Model) | IScopeIncludeOptions>;
+  include?: Array<ModelClassGetter | IScopeIncludeOptions>;
 
 }