Merge pull request #186 from RobinBuschmann/issue-#122

Issue #122

Author: RobinBuschmann

.gitignore

@@ -8,18 +8,21 @@
 # libraries
 node_modules
 
-# testing
-coverage
-.nyc_output
-
 #logs
 npm-debug.log
 
+# build
 **/*.js
 **/*.js.map
 **/*.d.ts
+
+# src
 !lib/models/Model.d.ts
 !lib/models/Model.js
 !lib/models/Sequelize.d.ts
 !lib/models/Sequelize.js
 
+# testing
+coverage
+.nyc_output
+!test/tsconfig.mocha.js

example/app.ts

@@ -10,7 +10,7 @@ import Book from "./models/Book";
 /* tslint:disable:no-console */
 /* tslint:disable:no-unused-new */
 
-new Sequelize({
+const s = new Sequelize({
   validateOnly: true,
   modelPaths: [__dirname + '/models/validation-only']
 });

index.ts

@@ -98,7 +98,6 @@ export {IScopeFindOptions} from "./lib/interfaces/IScopeFindOptions";
 export {IScopeIncludeAssociation} from "./lib/interfaces/IScopeIncludeAssociation";
 export {IScopeIncludeOptions} from "./lib/interfaces/IScopeIncludeOptions";
 export {IScopeOptions} from "./lib/interfaces/IScopeOptions";
-export {ISequelizeAssociation} from "./lib/interfaces/ISequelizeAssociation";
 export {ISequelizeConfig} from "./lib/interfaces/ISequelizeConfig";
 export {ISequelizeForeignKeyConfig} from "./lib/interfaces/ISequelizeForeignKeyConfig";
 export {ISequelizeValidationOnlyConfig} from "./lib/interfaces/ISequelizeValidationOnlyConfig";

lib/annotations/Column.ts

@@ -40,7 +40,7 @@ function annotate(target: any,
     };
   } else {
 
-    options = Object.assign({}, <IPartialDefineAttributeColumnOptions>optionsOrDataType);
+    options = Object.assign({}, optionsOrDataType as IPartialDefineAttributeColumnOptions);
 
     if (!options.type) {
       options.type = getSequelizeTypeByDesignType(target, propertyName);

lib/annotations/association/BelongsTo.ts

@@ -1,21 +1,22 @@
 import {AssociationOptionsBelongsTo} from 'sequelize';
-import {BELONGS_TO, addAssociation} from "../../services/association";
+import {addAssociation, getPreparedAssociationOptions} from "../../services/association";
 import {ModelClassGetter} from "../../types/ModelClassGetter";
+import {BelongsToAssociation} from '../../models/association/BelongsToAssociation';
 
-export function BelongsTo(relatedClassGetter: ModelClassGetter,
+export function BelongsTo(associatedClassGetter: ModelClassGetter,
                           foreignKey?: string): Function;
-export function BelongsTo(relatedClassGetter: ModelClassGetter,
+export function BelongsTo(associatedClassGetter: ModelClassGetter,
                           options?: AssociationOptionsBelongsTo): Function;
-export function BelongsTo(relatedClassGetter: ModelClassGetter,
+export function BelongsTo(associatedClassGetter: ModelClassGetter,
                           optionsOrForeignKey?: string | AssociationOptionsBelongsTo): Function {
 
   return (target: any, propertyName: string) => {
-    addAssociation(
-      target,
-      BELONGS_TO,
-      relatedClassGetter,
-      propertyName,
-      optionsOrForeignKey
+    const options: AssociationOptionsBelongsTo = getPreparedAssociationOptions(optionsOrForeignKey);
+    if (!options.as) options.as = propertyName;
+    addAssociation(target, new BelongsToAssociation(
+      associatedClassGetter,
+      options,
+      )
     );
   };
 }

lib/annotations/association/BelongsToMany.ts

@@ -1,36 +1,35 @@
-import {BELONGS_TO_MANY, addAssociation} from "../../services/association";
+import {addAssociation} from "../../services/association";
 import {ModelClassGetter} from "../../types/ModelClassGetter";
 import {IAssociationOptionsBelongsToMany} from "../../interfaces/IAssociationOptionsBelongsToMany";
+import {BelongsToManyAssociation} from '../../models/association/BelongsToManyAssociation';
 
-export function BelongsToMany(relatedClassGetter: ModelClassGetter,
-                              through: (ModelClassGetter) | string,
+export function BelongsToMany(associatedClassGetter: ModelClassGetter,
+                              through: ModelClassGetter | string,
                               foreignKey?: string,
                               otherKey?: string): Function;
-export function BelongsToMany(relatedClassGetter: ModelClassGetter,
+export function BelongsToMany(associatedClassGetter: ModelClassGetter,
                               options: IAssociationOptionsBelongsToMany): Function;
-export function BelongsToMany(relatedClassGetter: ModelClassGetter,
-                              throughOrOptions: (ModelClassGetter | string) | IAssociationOptionsBelongsToMany,
+export function BelongsToMany(associatedClassGetter: 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 as IAssociationOptionsBelongsToMany;
-  }
   return (target: any, propertyName: string) => {
-    addAssociation(
-      target,
-      BELONGS_TO_MANY,
-      relatedClassGetter,
-      propertyName,
-      options || foreignKey,
-      through,
-      otherKey,
+    let options: Partial<IAssociationOptionsBelongsToMany> = {foreignKey, otherKey};
+
+    if (typeof throughOrOptions === 'string' ||
+      typeof throughOrOptions === 'function') {
+      options.through = throughOrOptions;
+    } else {
+      options = {...throughOrOptions};
+    }
+
+    if (!options.as) options.as = propertyName;
+
+    addAssociation(target, new BelongsToManyAssociation(
+      associatedClassGetter,
+      options as IAssociationOptionsBelongsToMany,
+      )
     );
   };
 }

lib/annotations/association/HasMany.ts

@@ -1,20 +1,24 @@
 import {AssociationOptionsHasMany} from 'sequelize';
-import {HAS_MANY, addAssociation} from "../../services/association";
+import {addAssociation, getPreparedAssociationOptions} from "../../services/association";
+import {Association} from "../../enums/Association";
 import {ModelClassGetter} from "../../types/ModelClassGetter";
+import {HasAssociation} from '../../models/association/HasAssociation';
 
-export function HasMany(relatedClassGetter: ModelClassGetter,
+export function HasMany(associatedClassGetter: ModelClassGetter,
                         foreignKey?: string): Function;
-export function HasMany(relatedClassGetter: ModelClassGetter,
+export function HasMany(associatedClassGetter: ModelClassGetter,
                         options?: AssociationOptionsHasMany): Function;
-export function HasMany(relatedClassGetter: ModelClassGetter,
+export function HasMany(associatedClassGetter: ModelClassGetter,
                         optionsOrForeignKey?: string | AssociationOptionsHasMany): Function {
+
   return (target: any, propertyName: string) => {
-    addAssociation(
-      target,
-      HAS_MANY,
-      relatedClassGetter,
-      propertyName,
-      optionsOrForeignKey,
+    const options: AssociationOptionsHasMany = getPreparedAssociationOptions(optionsOrForeignKey);
+    if (!options.as) options.as = propertyName;
+    addAssociation(target, new HasAssociation(
+      associatedClassGetter,
+      options,
+      Association.HasMany,
+      )
     );
   };
 }

lib/annotations/association/HasOne.ts

@@ -1,20 +1,24 @@
 import {AssociationOptionsHasOne} from 'sequelize';
-import {addAssociation, HAS_ONE} from "../../services/association";
+import {Association} from "../../enums/Association";
 import {ModelClassGetter} from "../../types/ModelClassGetter";
+import {addAssociation, getPreparedAssociationOptions} from '../../services/association';
+import {HasAssociation} from '../../models/association/HasAssociation';
 
-export function HasOne(relatedClassGetter: ModelClassGetter,
+export function HasOne(associatedClassGetter: ModelClassGetter,
                        foreignKey?: string): Function;
-export function HasOne(relatedClassGetter: ModelClassGetter,
+export function HasOne(associatedClassGetter: ModelClassGetter,
                        options?: AssociationOptionsHasOne): Function;
-export function HasOne(relatedClassGetter: ModelClassGetter,
+export function HasOne(associatedClassGetter: ModelClassGetter,
                        optionsOrForeignKey?: string | AssociationOptionsHasOne): Function {
+
   return (target: any, propertyName: string) => {
-    addAssociation(
-      target,
-      HAS_ONE,
-      relatedClassGetter,
-      propertyName,
-      optionsOrForeignKey,
+    const options: AssociationOptionsHasOne = getPreparedAssociationOptions(optionsOrForeignKey);
+    if (!options.as) options.as = propertyName;
+    addAssociation(target, new HasAssociation(
+      associatedClassGetter,
+      options,
+      Association.HasOne,
+      )
     );
   };
 }

lib/enums/Association.ts

@@ -0,0 +1,6 @@
+export enum Association {
+  BelongsToMany = 'belongsToMany',
+  BelongsTo = 'belongsTo',
+  HasMany = 'hasMany',
+  HasOne = 'hasOne',
+}

lib/interfaces/AssociationOptions.ts

@@ -0,0 +1,12 @@
+import {
+  AssociationOptionsBelongsTo, AssociationOptionsHasMany,
+  AssociationOptionsHasOne, AssociationOptionsManyToMany
+} from 'sequelize';
+import {IPreparedAssociationOptionsBelongsToMany} from './IPreparedAssociationOptionsBelongsToMany';
+
+export type AssociationOptions =
+  AssociationOptionsBelongsTo |
+  IPreparedAssociationOptionsBelongsToMany |
+  AssociationOptionsHasMany |
+  AssociationOptionsHasOne |
+  AssociationOptionsManyToMany;