created metadata args for all metadatas

sample/sample10-mixed/entity/Post.ts

@@ -43,10 +43,10 @@ export class Post {
     secondaryImages: Image[];
 
     @ManyToOne(type => Cover, cover => cover.posts, {
-        name: "coverId",
         cascadeInsert: true,
         cascadeRemove: true
     })
+    @JoinColumn({ name: "coverId" })
     cover: Cover;
 
     @Column("int", {

src/connection/Connection.ts

@@ -8,7 +8,7 @@ import {ConstructorFunction} from "../common/ConstructorFunction";
 import {EntityListenerMetadata} from "../metadata/EntityListenerMetadata";
 import {EntityManager} from "../entity-manager/EntityManager";
 import {importClassesFromDirectories} from "../util/DirectoryExportedClassesLoader";
-import {defaultMetadataStorage, getFromContainer} from "../index";
+import {getMetadataArgsStorage, getFromContainer} from "../index";
 import {EntityMetadataBuilder} from "../metadata-storage/EntityMetadataBuilder";
 import {DefaultNamingStrategy} from "../naming-strategy/DefaultNamingStrategy";
 import {EntityMetadataCollection} from "../metadata/collection/EntityMetadataCollection";
@@ -347,20 +347,20 @@ export class Connection {
     private buildMetadatas() {
 
         // take imported naming strategy metadatas
-        defaultMetadataStorage()
+        getMetadataArgsStorage()
             .namingStrategyMetadatas
             .filterByClasses(this.namingStrategyClasses)
             .forEach(namingStrategy => this.namingStrategyMetadatas.push(namingStrategy));
 
         // take imported event subscribers
-        defaultMetadataStorage()
+        getMetadataArgsStorage()
             .eventSubscriberMetadatas
             .filterByClasses(this.subscriberClasses)
             .map(metadata => getFromContainer(metadata.target))
             .forEach(subscriber => this.eventSubscribers.push(subscriber));
 
         // take imported entity listeners
-        defaultMetadataStorage()
+        getMetadataArgsStorage()
             .entityListenerMetadatas
             .filterByClasses(this.entityClasses)
             .forEach(entityListener => this.entityListeners.push(entityListener));

src/connection/ConnectionOptions.ts

@@ -1,5 +1,5 @@
 /**
- * Connection options passed to the document.
+ * Connection options passed to the connection.
  */
 export interface ConnectionOptions {
 

src/decorator/NamingStrategy.ts

@@ -1,5 +1,5 @@
-import {NamingStrategyMetadata} from "../metadata/NamingStrategyMetadata";
-import {defaultMetadataStorage} from "../index";
+import {getMetadataArgsStorage} from "../index";
+import {NamingStrategyMetadataArgs} from "../metadata/args/NamingStrategyMetadataArgs";
 
 /**
  * Decorator registers a new naming strategy to be used in naming things.
@@ -7,6 +7,10 @@ import {defaultMetadataStorage} from "../index";
 export function NamingStrategy(name?: string): Function {
     return function (target: Function) {
         const strategyName = name ? name : (<any> target).name;
-        defaultMetadataStorage().namingStrategyMetadatas.add(new NamingStrategyMetadata(target, strategyName));
+        const metadata: NamingStrategyMetadataArgs = {
+            target: target,
+            name: strategyName
+        };
+        getMetadataArgsStorage().namingStrategyMetadatas.add(metadata);
     };
 }

src/decorator/columns/Column.ts

@@ -1,9 +1,9 @@
 import {ColumnOptions} from "../../metadata/options/ColumnOptions";
 import {ColumnTypeUndefinedError} from "../error/ColumnTypeUndefinedError";
 import {AutoIncrementOnlyForPrimaryError} from "../error/AutoIncrementOnlyForPrimaryError";
-import {defaultMetadataStorage} from "../../index";
-import {ColumnMetadata} from "../../metadata/ColumnMetadata";
+import {getMetadataArgsStorage} from "../../index";
 import {ColumnType, ColumnTypes} from "../../metadata/types/ColumnTypes";
+import {ColumnMetadataArgs} from "../../metadata/args/ColumnMetadataArgs";
 
 /**
  * Column decorator is used to mark a specific class property as a table column. Only properties decorated with this 
@@ -53,11 +53,12 @@ export function Column(typeOrOptions?: ColumnType|ColumnOptions, options?: Colum
             throw new AutoIncrementOnlyForPrimaryError(object, propertyName);
 
         // create and register a new column metadata
-        defaultMetadataStorage().columnMetadatas.add(new ColumnMetadata({
+        const metadata: ColumnMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
             options: options
-        }));
+        };
+        getMetadataArgsStorage().columnMetadatas.add(metadata);
     };
 }

src/decorator/columns/CreateDateColumn.ts

@@ -1,7 +1,8 @@
 import {ColumnOptions} from "../../metadata/options/ColumnOptions";
-import {ColumnType, ColumnTypes} from "../../metadata/types/ColumnTypes";
-import {defaultMetadataStorage} from "../../index";
+import {ColumnTypes} from "../../metadata/types/ColumnTypes";
+import {getMetadataArgsStorage} from "../../index";
 import {ColumnMetadata} from "../../metadata/ColumnMetadata";
+import {ColumnMetadataArgs} from "../../metadata/args/ColumnMetadataArgs";
 
 /**
  * This column will store a creation date of the inserted object. Creation date is generated and inserted only once,
@@ -19,13 +20,14 @@ export function CreateDateColumn(options?: ColumnOptions): Function {
         options.type = ColumnTypes.DATETIME;
 
         // create and register a new column metadata
-        defaultMetadataStorage().columnMetadatas.add(new ColumnMetadata({
+        const metadata: ColumnMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
             mode: "createDate",
             options: options
-        }));
+        };
+        getMetadataArgsStorage().columnMetadatas.add(metadata);
     };
 }
 

src/decorator/columns/PrimaryColumn.ts

@@ -1,9 +1,9 @@
 import {ColumnOptions} from "../../metadata/options/ColumnOptions";
 import {ColumnType, ColumnTypes} from "../../metadata/types/ColumnTypes";
 import {ColumnTypeUndefinedError} from "../error/ColumnTypeUndefinedError";
-import {defaultMetadataStorage} from "../../index";
-import {ColumnMetadata} from "../../metadata/ColumnMetadata";
+import {getMetadataArgsStorage} from "../../index";
 import {PrimaryColumnCannotBeNullableError} from "../error/PrimaryColumnCannotBeNullableError";
+import {ColumnMetadataArgs} from "../../metadata/args/ColumnMetadataArgs";
 
 /**
  * Column decorator is used to mark a specific class property as a table column. Only properties decorated with this
@@ -55,13 +55,14 @@ export function PrimaryColumn(typeOrOptions?: ColumnType|ColumnOptions, options?
             throw new PrimaryColumnCannotBeNullableError(object, propertyName);
 
         // create and register a new column metadata
-        defaultMetadataStorage().columnMetadatas.add(new ColumnMetadata({
+        const metadata: ColumnMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
             isPrimaryKey: true,
             options: options
-        }));
+        };
+        getMetadataArgsStorage().columnMetadatas.add(metadata);
     };
 }
 

src/decorator/columns/RelationsCountColumn.ts

@@ -1,5 +1,5 @@
-import {defaultMetadataStorage} from "../../index";
-import {RelationsCountMetadata} from "../../metadata/RelationsCountMetadata";
+import {getMetadataArgsStorage} from "../../index";
+import {RelationsCountMetadataArgs} from "../../metadata/args/RelationsCountMetadataArgs";
 
 /**
  * Holds a number of children in the closure table of the column.
@@ -11,7 +11,12 @@ export function RelationsCountColumn<T>(relation: string|((object: T) => any)):
         // const reflectedType = ColumnTypes.typeToString((<any> Reflect).getMetadata("design:type", object, propertyName));
 
         // create and register a new column metadata
-        defaultMetadataStorage().relationCountMetadatas.add(new RelationsCountMetadata(object.constructor, propertyName, relation));
+        const metadata: RelationsCountMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            relation: relation
+        };
+        getMetadataArgsStorage().relationCountMetadatas.add(metadata);
     };
 }
 

src/decorator/columns/UpdateDateColumn.ts

@@ -1,7 +1,7 @@
 import {ColumnOptions} from "../../metadata/options/ColumnOptions";
 import {ColumnTypes} from "../../metadata/types/ColumnTypes";
-import {defaultMetadataStorage} from "../../index";
-import {ColumnMetadata} from "../../metadata/ColumnMetadata";
+import {getMetadataArgsStorage} from "../../index";
+import {ColumnMetadataArgs} from "../../metadata/args/ColumnMetadataArgs";
 
 /**
  * This column will store an update date of the updated object. This date is being updated each time you persist the
@@ -19,13 +19,14 @@ export function UpdateDateColumn(options?: ColumnOptions): Function {
         options.type = ColumnTypes.DATETIME;
 
         // create and register a new column metadata
-        defaultMetadataStorage().columnMetadatas.add(new ColumnMetadata({
+        const metadata: ColumnMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
             mode: "updateDate",
             options: options
-        }));
+        };
+        getMetadataArgsStorage().columnMetadatas.add(metadata);
     };
 }
 

src/decorator/columns/VersionColumn.ts

@@ -1,7 +1,7 @@
 import {ColumnOptions} from "../../metadata/options/ColumnOptions";
 import {ColumnTypes} from "../../metadata/types/ColumnTypes";
-import {defaultMetadataStorage} from "../../index";
-import {ColumnMetadata} from "../../metadata/ColumnMetadata";
+import {getMetadataArgsStorage} from "../../index";
+import {ColumnMetadataArgs} from "../../metadata/args/ColumnMetadataArgs";
 
 /**
  * This column will store a number - version of the entity. Every time your entity will be persisted, this number will
@@ -21,13 +21,14 @@ export function VersionColumn(options?: ColumnOptions): Function {
         // todo: check if reflectedType is number too
 
         // create and register a new column metadata
-        defaultMetadataStorage().columnMetadatas.add(new ColumnMetadata({
+        const metadata: ColumnMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
             mode: "version",
             options: options
-        }));
+        };
+        getMetadataArgsStorage().columnMetadatas.add(metadata);
     };
 }
 

src/decorator/indices/CompositeIndex.ts

@@ -1,6 +1,6 @@
-import {CompositeIndexMetadata} from "../../metadata/CompositeIndexMetadata";
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {CompositeIndexOptions} from "../../metadata/options/CompositeIndexOptions";
+import {CompositeIndexMetadataArgs} from "../../metadata/args/CompositeIndexMetadataArgs";
 
 /**
  * Composite indexes must be set on entity classes and must specify fields to be indexed.
@@ -17,6 +17,12 @@ export function CompositeIndex(nameOrFields: string|string[]|((object: any) => a
     const options = typeof maybeFieldsOrOptions === "object" ? <CompositeIndexOptions> maybeFieldsOrOptions : maybeOptions;
     
     return function (cls: Function) {
-        defaultMetadataStorage().compositeIndexMetadatas.add(new CompositeIndexMetadata(cls, name, fields, options));
+        const metadata: CompositeIndexMetadataArgs = {
+            target: cls,
+            name: name,
+            columns: fields,
+            options: options
+        };
+        getMetadataArgsStorage().compositeIndexMetadatas.add(metadata);
     };
 }

src/decorator/indices/Index.ts

@@ -1,11 +1,16 @@
-import {defaultMetadataStorage} from "../../index";
-import {IndexMetadata} from "../../metadata/IndexMetadata";
+import {getMetadataArgsStorage} from "../../index";
+import {IndexMetadataArgs} from "../../metadata/args/IndexMetadataArgs";
 
 /**
  * Fields that needs to be indexed must be marked with this decorator.
  */
 export function Index(name?: string) {
     return function (object: Object, propertyName: string) {
-        defaultMetadataStorage().indexMetadatas.add(new IndexMetadata(object.constructor, propertyName, name));
+        const metadata: IndexMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            name: name
+        };
+        getMetadataArgsStorage().indexMetadatas.add(metadata);
     };
 }

src/decorator/listeners/AfterInsert.ts

@@ -1,16 +1,18 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {EventListenerTypes} from "../../metadata/types/EventListenerTypes";
-import {EntityListenerMetadata} from "../../metadata/EntityListenerMetadata";
+import {EntityListenerMetadataArgs} from "../../metadata/args/EntityListenerMetadataArgs";
 
 /**
  * Calls a method on which this decorator is applied after this entity insertion.
  */
 export function AfterInsert() {
     return function (object: Object, propertyName: string) {
-        defaultMetadataStorage().entityListenerMetadatas.add(new EntityListenerMetadata(
-            object.constructor, 
-            propertyName, 
-            EventListenerTypes.AFTER_INSERT
-        ));
+
+        const metadata: EntityListenerMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            type: EventListenerTypes.AFTER_INSERT
+        };
+        getMetadataArgsStorage().entityListenerMetadatas.add(metadata);
     };
 }

src/decorator/listeners/AfterLoad.ts

@@ -1,16 +1,17 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {EventListenerTypes} from "../../metadata/types/EventListenerTypes";
-import {EntityListenerMetadata} from "../../metadata/EntityListenerMetadata";
+import {EntityListenerMetadataArgs} from "../../metadata/args/EntityListenerMetadataArgs";
 
 /**
  * Calls a method on which this decorator is applied after entity is loaded.
  */
 export function AfterLoad() {
     return function (object: Object, propertyName: string) {
-        defaultMetadataStorage().entityListenerMetadatas.add(new EntityListenerMetadata(
-            object.constructor, 
-            propertyName, 
-            EventListenerTypes.AFTER_LOAD
-        ));
+        const metadata: EntityListenerMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            type: EventListenerTypes.AFTER_LOAD
+        };
+        getMetadataArgsStorage().entityListenerMetadatas.add(metadata);
     };
 }

src/decorator/listeners/AfterRemove.ts

@@ -1,16 +1,17 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {EventListenerTypes} from "../../metadata/types/EventListenerTypes";
-import {EntityListenerMetadata} from "../../metadata/EntityListenerMetadata";
+import {EntityListenerMetadataArgs} from "../../metadata/args/EntityListenerMetadataArgs";
 
 /**
  * Calls a method on which this decorator is applied after this entity removal.
  */
 export function AfterRemove() {
     return function (object: Object, propertyName: string) {
-        defaultMetadataStorage().entityListenerMetadatas.add(new EntityListenerMetadata(
-            object.constructor, 
-            propertyName, 
-            EventListenerTypes.AFTER_REMOVE
-        ));
+        const metadata: EntityListenerMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            type: EventListenerTypes.AFTER_REMOVE
+        };
+        getMetadataArgsStorage().entityListenerMetadatas.add(metadata);
     };
 }

src/decorator/listeners/AfterUpdate.ts

@@ -1,16 +1,17 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {EventListenerTypes} from "../../metadata/types/EventListenerTypes";
-import {EntityListenerMetadata} from "../../metadata/EntityListenerMetadata";
+import {EntityListenerMetadataArgs} from "../../metadata/args/EntityListenerMetadataArgs";
 
 /**
  * Calls a method on which this decorator is applied after this entity update.
  */
 export function AfterUpdate() {
     return function (object: Object, propertyName: string) {
-        defaultMetadataStorage().entityListenerMetadatas.add(new EntityListenerMetadata(
-            object.constructor, 
-            propertyName, 
-            EventListenerTypes.AFTER_UPDATE
-        ));
+        const metadata: EntityListenerMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            type: EventListenerTypes.AFTER_UPDATE
+        };
+        getMetadataArgsStorage().entityListenerMetadatas.add(metadata);
     };
 }

src/decorator/listeners/BeforeInsert.ts

@@ -1,16 +1,17 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {EventListenerTypes} from "../../metadata/types/EventListenerTypes";
-import {EntityListenerMetadata} from "../../metadata/EntityListenerMetadata";
+import {EntityListenerMetadataArgs} from "../../metadata/args/EntityListenerMetadataArgs";
 
 /**
  * Calls a method on which this decorator is applied before this entity insertion.
  */
 export function BeforeInsert() {
     return function (object: Object, propertyName: string) {
-        defaultMetadataStorage().entityListenerMetadatas.add(new EntityListenerMetadata(
-            object.constructor, 
-            propertyName, 
-            EventListenerTypes.BEFORE_INSERT
-        ));
+        const metadata: EntityListenerMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            type: EventListenerTypes.BEFORE_INSERT
+        };
+        getMetadataArgsStorage().entityListenerMetadatas.add(metadata);
     };
 }

src/decorator/listeners/BeforeRemove.ts

@@ -1,16 +1,17 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {EventListenerTypes} from "../../metadata/types/EventListenerTypes";
-import {EntityListenerMetadata} from "../../metadata/EntityListenerMetadata";
+import {EntityListenerMetadataArgs} from "../../metadata/args/EntityListenerMetadataArgs";
 
 /**
  * Calls a method on which this decorator is applied before this entity removal.
  */
 export function BeforeRemove() {
     return function (object: Object, propertyName: string) {
-        defaultMetadataStorage().entityListenerMetadatas.add(new EntityListenerMetadata(
-            object.constructor, 
-            propertyName, 
-            EventListenerTypes.BEFORE_REMOVE
-        ));
+        const metadata: EntityListenerMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            type: EventListenerTypes.BEFORE_REMOVE
+        };
+        getMetadataArgsStorage().entityListenerMetadatas.add(metadata);
     };
 }

src/decorator/listeners/BeforeUpdate.ts

@@ -1,16 +1,17 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {EventListenerTypes} from "../../metadata/types/EventListenerTypes";
-import {EntityListenerMetadata} from "../../metadata/EntityListenerMetadata";
+import {EntityListenerMetadataArgs} from "../../metadata/args/EntityListenerMetadataArgs";
 
 /**
  * Calls a method on which this decorator is applied before this entity update.
  */
 export function BeforeUpdate() {
     return function (object: Object, propertyName: string) {
-        defaultMetadataStorage().entityListenerMetadatas.add(new EntityListenerMetadata(
-            object.constructor, 
-            propertyName, 
-            EventListenerTypes.BEFORE_UPDATE
-        ));
+        const metadata: EntityListenerMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            type: EventListenerTypes.BEFORE_UPDATE
+        };
+        getMetadataArgsStorage().entityListenerMetadatas.add(metadata);
     };
 }

src/decorator/listeners/EventSubscriber.ts

@@ -1,5 +1,5 @@
-import {defaultMetadataStorage} from "../../index";
-import {EventSubscriberMetadata} from "../../metadata/EventSubscriberMetadata";
+import {getMetadataArgsStorage} from "../../index";
+import {EventSubscriberMetadataArgs} from "../../metadata/args/EventSubscriberMetadataArgs";
 
 /**
  * Classes decorated with this decorator will listen to ORM events and their methods will be triggered when event
@@ -7,6 +7,9 @@ import {EventSubscriberMetadata} from "../../metadata/EventSubscriberMetadata";
  */
 export function EventSubscriber() {
     return function (target: Function) {
-        defaultMetadataStorage().eventSubscriberMetadatas.add(new EventSubscriberMetadata(target));
+        const metadata: EventSubscriberMetadataArgs = {
+            target: target
+        };
+        getMetadataArgsStorage().eventSubscriberMetadatas.add(metadata);
     };
 }

src/decorator/relations/JoinColumn.ts

@@ -1,14 +1,18 @@
-import {defaultMetadataStorage} from "../../index";
-import {JoinColumnMetadata} from "../../metadata/JoinColumnMetadata";
+import {getMetadataArgsStorage} from "../../index";
 import {JoinColumnOptions} from "../../metadata/options/JoinColumnOptions";
+import {JoinColumnMetadataArgs} from "../../metadata/args/JoinColumnMetadataArgs";
 
 /**
  */
 export function JoinColumn(options?: JoinColumnOptions): Function {
     return function (object: Object, propertyName: string) {
         options = options || {} as JoinColumnOptions;
-        const metadata = new JoinColumnMetadata(object.constructor, propertyName, options);
-        defaultMetadataStorage().joinColumnMetadatas.add(metadata);
+        const metadata: JoinColumnMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            options: options
+        };
+        getMetadataArgsStorage().joinColumnMetadatas.add(metadata);
     };
 }
 

src/decorator/relations/JoinTable.ts

@@ -1,14 +1,18 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {JoinTableOptions} from "../../metadata/options/JoinTableOptions";
-import {JoinTableMetadata} from "../../metadata/JoinTableMetadata";
+import {JoinTableMetadataArgs} from "../../metadata/args/JoinTableMetadataArgs";
 
 /**
  */
 export function JoinTable(options?: JoinTableOptions): Function {
     return function (object: Object, propertyName: string) {
         options = options || {} as JoinTableOptions;
-        const metadata = new JoinTableMetadata(object.constructor, propertyName, options);
-        defaultMetadataStorage().joinTableMetadatas.add(metadata);
+        const metadata: JoinTableMetadataArgs = {
+            target: object.constructor,
+            propertyName: propertyName,
+            options: options
+        };
+        getMetadataArgsStorage().joinTableMetadatas.add(metadata);
     };
 }
 

src/decorator/relations/ManyToMany.ts

@@ -1,8 +1,8 @@
-import {RelationMetadata} from "../../metadata/RelationMetadata";
 import {RelationOptions} from "../../metadata/options/RelationOptions";
 import {RelationTypes} from "../../metadata/types/RelationTypes";
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {ConstructorFunction} from "../../common/ConstructorFunction";
+import {RelationMetadataArgs} from "../../metadata/args/RelationMetadataArgs";
 
 /**
  * Many-to-many is a type of relationship when Entity1 can have multiple instances of Entity2, and Entity2 can have
@@ -40,7 +40,7 @@ export function ManyToMany<T>(typeFunction: (type?: any) => ConstructorFunction<
         
         const reflectedType = (<any> Reflect).getMetadata("design:type", object, propertyName);
 
-        defaultMetadataStorage().relationMetadatas.add(new RelationMetadata({
+        const metadata: RelationMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
@@ -48,7 +48,8 @@ export function ManyToMany<T>(typeFunction: (type?: any) => ConstructorFunction<
             type: typeFunction,
             inverseSideProperty: inverseSideProperty,
             options: options
-        }));
+        };
+        getMetadataArgsStorage().relationMetadatas.add(metadata);
     };
 }
 

src/decorator/relations/ManyToOne.ts

@@ -1,8 +1,8 @@
-import {RelationMetadata} from "../../metadata/RelationMetadata";
 import {RelationOptions} from "../../metadata/options/RelationOptions";
 import {RelationTypes} from "../../metadata/types/RelationTypes";
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {ConstructorFunction} from "../../common/ConstructorFunction";
+import {RelationMetadataArgs} from "../../metadata/args/RelationMetadataArgs";
 
 /**
  * Many-to-one relation allows to create type of relation when Entity1 can have single instance of Entity2, but
@@ -40,7 +40,7 @@ export function ManyToOne<T>(typeFunction: (type?: any) => ConstructorFunction<T
 
         const reflectedType = (<any> Reflect).getMetadata("design:type", object, propertyName);
 
-        defaultMetadataStorage().relationMetadatas.add(new RelationMetadata({
+        const metadata: RelationMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
@@ -48,6 +48,7 @@ export function ManyToOne<T>(typeFunction: (type?: any) => ConstructorFunction<T
             type: typeFunction,
             inverseSideProperty: inverseSideProperty,
             options: options
-        }));
+        };
+        getMetadataArgsStorage().relationMetadatas.add(metadata);
     };
 }

src/decorator/relations/OneToMany.ts

@@ -1,8 +1,8 @@
-import {RelationMetadata} from "../../metadata/RelationMetadata";
 import {RelationOptions} from "../../metadata/options/RelationOptions";
 import {RelationTypes} from "../../metadata/types/RelationTypes";
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {ConstructorFunction} from "../../common/ConstructorFunction";
+import {RelationMetadataArgs} from "../../metadata/args/RelationMetadataArgs";
 
 // todo: make decorators which use inverse side string separate
 
@@ -42,7 +42,7 @@ export function OneToMany<T>(typeFunction: (type?: any) => ConstructorFunction<T
 
         const reflectedType = (<any> Reflect).getMetadata("design:type", object, propertyName);
 
-        defaultMetadataStorage().relationMetadatas.add(new RelationMetadata({
+        const metadata: RelationMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
@@ -50,7 +50,8 @@ export function OneToMany<T>(typeFunction: (type?: any) => ConstructorFunction<T
             type: typeFunction,
             inverseSideProperty: inverseSideProperty,
             options: options
-        }));
+        };
+        getMetadataArgsStorage().relationMetadatas.add(metadata);
     };
 }
 

src/decorator/relations/OneToOne.ts

@@ -1,8 +1,8 @@
-import {RelationMetadata} from "../../metadata/RelationMetadata";
 import {RelationOptions} from "../../metadata/options/RelationOptions";
 import {RelationTypes} from "../../metadata/types/RelationTypes";
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {ConstructorFunction} from "../../common/ConstructorFunction";
+import {RelationMetadataArgs} from "../../metadata/args/RelationMetadataArgs";
 
 /**
  * One-to-one relation allows to create direct relation between two entities. Entity1 have only one Entity2.
@@ -37,7 +37,7 @@ export function OneToOne<T>(typeFunction: (type?: any) => ConstructorFunction<T>
 
         const reflectedType = (<any> Reflect).getMetadata("design:type", object, propertyName);
 
-        defaultMetadataStorage().relationMetadatas.add(new RelationMetadata({
+        const metadata: RelationMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
@@ -45,6 +45,7 @@ export function OneToOne<T>(typeFunction: (type?: any) => ConstructorFunction<T>
             type: typeFunction,
             inverseSideProperty: inverseSideProperty,
             options: options
-        }));
+        };
+        getMetadataArgsStorage().relationMetadatas.add(metadata);
     };
 }

src/decorator/tables/AbstractTable.ts

@@ -1,11 +1,16 @@
-import {TableMetadata} from "../../metadata/TableMetadata";
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
+import {TableMetadataArgs} from "../../metadata/args/TableMetadataArgs";
 
 /**
  * Allows to use columns and relations data from the inherited metadata.
  */
 export function AbstractTable() {
-    return function (cls: Function) {
-        defaultMetadataStorage().tableMetadatas.add(new TableMetadata(cls, undefined, "abstract"));
+    return function (target: Function) {
+        const metadata: TableMetadataArgs = {
+            target: target,
+            name: undefined,
+            type: "abstract"
+        };
+        getMetadataArgsStorage().tableMetadatas.add(metadata);
     };
 }

src/decorator/tables/ClosureTable.ts

@@ -1,12 +1,17 @@
-import {defaultMetadataStorage} from "../../index";
-import {TableMetadata} from "../../metadata/TableMetadata";
+import {getMetadataArgsStorage} from "../../index";
+import {TableMetadataArgs} from "../../metadata/args/TableMetadataArgs";
 
 /**
  * This decorator is used to mark classes that will be a tables. Database schema will be created for all classes
  * decorated with it, and Repository can be retrieved and used for it.
  */
 export function ClosureTable(name?: string) {
-    return function (cls: Function) {
-        defaultMetadataStorage().tableMetadatas.add(new TableMetadata(cls, name, "closure"));
+    return function (target: Function) {
+        const metadata: TableMetadataArgs = {
+            target: target,
+            name: name,
+            type: "closure"
+        };
+        getMetadataArgsStorage().tableMetadatas.add(metadata);
     };
 }

src/decorator/tables/Table.ts

@@ -1,12 +1,17 @@
-import {defaultMetadataStorage} from "../../index";
-import {TableMetadata} from "../../metadata/TableMetadata";
+import {getMetadataArgsStorage} from "../../index";
+import {TableMetadataArgs} from "../../metadata/args/TableMetadataArgs";
 
 /**
  * This decorator is used to mark classes that will be a tables. Database schema will be created for all classes
  * decorated with it, and Repository can be retrieved and used for it.
  */
 export function Table(name?: string) {
-    return function (cls: Function) {
-        defaultMetadataStorage().tableMetadatas.add(new TableMetadata(cls, name));
+    return function (target: Function) {
+        const metadata: TableMetadataArgs = {
+            target: target,
+            name: name,
+            type: "regular"
+        };
+        getMetadataArgsStorage().tableMetadatas.add(metadata);
     };
 }

src/decorator/tree/TreeChildren.ts

@@ -1,7 +1,7 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {RelationOptions} from "../../metadata/options/RelationOptions";
-import {RelationMetadata} from "../../metadata/RelationMetadata";
 import {RelationTypes} from "../../metadata/types/RelationTypes";
+import {RelationMetadataArgs} from "../../metadata/args/RelationMetadataArgs";
 
 /**
  * Marks a specific property of the class as a children of the tree.
@@ -13,7 +13,7 @@ export function TreeChildren(options?: RelationOptions): Function {
         const reflectedType = (<any> Reflect).getMetadata("design:type", object, propertyName);
         
         // add one-to-many relation for this 
-        defaultMetadataStorage().relationMetadatas.add(new RelationMetadata({
+        const metadata: RelationMetadataArgs = {
             isTreeChildren: true,
             target: object.constructor,
             propertyName: propertyName,
@@ -21,7 +21,8 @@ export function TreeChildren(options?: RelationOptions): Function {
             relationType: RelationTypes.ONE_TO_MANY,
             type: () => object.constructor,
             options: options
-        }));
+        };
+        getMetadataArgsStorage().relationMetadatas.add(metadata);
     };
 }
 

src/decorator/tree/TreeLevelColumn.ts

@@ -1,7 +1,7 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {ColumnTypes} from "../../metadata/types/ColumnTypes";
 import {ColumnOptions} from "../../metadata/options/ColumnOptions";
-import {ColumnMetadata} from "../../metadata/ColumnMetadata";
+import {ColumnMetadataArgs} from "../../metadata/args/ColumnMetadataArgs";
 
 /**
  * Creates a "level"/"length" column to the table that holds a closure table.
@@ -18,13 +18,14 @@ export function TreeLevelColumn(): Function {
         options.type = ColumnTypes.INTEGER;
 
         // create and register a new column metadata
-        defaultMetadataStorage().columnMetadatas.add(new ColumnMetadata({
+        const metadata: ColumnMetadataArgs = {
             target: object.constructor,
             propertyName: propertyName,
             propertyType: reflectedType,
             mode: "treeLevel",
             options: options
-        }));
+        };
+        getMetadataArgsStorage().columnMetadatas.add(metadata);
     };
 }
 

src/decorator/tree/TreeParent.ts

@@ -1,7 +1,7 @@
-import {defaultMetadataStorage} from "../../index";
+import {getMetadataArgsStorage} from "../../index";
 import {RelationOptions} from "../../metadata/options/RelationOptions";
-import {RelationMetadata} from "../../metadata/RelationMetadata";
 import {RelationTypes} from "../../metadata/types/RelationTypes";
+import {RelationMetadataArgs} from "../../metadata/args/RelationMetadataArgs";
 
 /**
  * Marks a specific property of the class as a parent of the tree.
@@ -11,7 +11,7 @@ export function TreeParent(options?: RelationOptions): Function {
         if (!options) options = {} as RelationOptions;
 
         const reflectedType = (<any> Reflect).getMetadata("design:type", object, propertyName);
-        defaultMetadataStorage().relationMetadatas.add(new RelationMetadata({
+        const metadata: RelationMetadataArgs = {
             isTreeParent: true,
             target: object.constructor,
             propertyName: propertyName,
@@ -19,7 +19,8 @@ export function TreeParent(options?: RelationOptions): Function {
             relationType: RelationTypes.MANY_TO_ONE,
             type: () => object.constructor,
             options: options
-        }));
+        };
+        getMetadataArgsStorage().relationMetadatas.add(metadata);
     };
 }
 

src/index.ts

@@ -6,7 +6,7 @@ import {ConnectionOptions} from "./connection/ConnectionOptions";
 import {ConnectionManager} from "./connection-manager/ConnectionManager";
 import {Connection} from "./connection/Connection";
 import {MysqlDriver} from "./driver/MysqlDriver";
-import {MetadataStorage} from "./metadata-storage/MetadataStorage";
+import {MetadataArgsStorage} from "./metadata-storage/MetadataStorage";
 import {CreateConnectionOptions} from "./connection-manager/CreateConnectionOptions";
 
 // -------------------------------------------------------------------------
@@ -50,17 +50,20 @@ export function getFromContainer<T>(someClass: { new (...args: any[]): T }|Funct
 /**
  * Default metadata storage used as singleton and can be used to storage all metadatas in the system.
  */
-let metadataStorage: MetadataStorage;
+let metadataArgsStorage: MetadataArgsStorage;
 
-export function defaultMetadataStorage() {
-    if (!metadataStorage && container) {
-        metadataStorage = container.get(MetadataStorage);
+/**
+ * Gets metadata args storage.
+ */
+export function getMetadataArgsStorage() {
+    if (!metadataArgsStorage && container) {
+        metadataArgsStorage = container.get(MetadataArgsStorage);
         
-    } else if (!metadataStorage) {
-        metadataStorage = new MetadataStorage();
+    } else if (!metadataArgsStorage) {
+        metadataArgsStorage = new MetadataArgsStorage();
     }
     
-    return metadataStorage;
+    return metadataArgsStorage;
 }
 
 // -------------------------------------------------------------------------

src/metadata-storage/EntityMetadataBuilder.ts

@@ -12,7 +12,7 @@ import {JoinColumnMetadata} from "../metadata/JoinColumnMetadata";
 import {JoinColumnOptions} from "../metadata/options/JoinColumnOptions";
 import {TableMetadata} from "../metadata/TableMetadata";
 import {ColumnTypes} from "../metadata/types/ColumnTypes";
-import {defaultMetadataStorage} from "../index";
+import {getMetadataArgsStorage} from "../index";
 
 /**
  * Aggregates all metadata: table, column, relation into one collection grouped by tables for a given set of classes.
@@ -49,7 +49,7 @@ export class EntityMetadataBuilder {
     build(namingStrategy: NamingStrategyInterface, 
           entityClasses: Function[]): EntityMetadata[] {
         
-        const allMetadataStorage = defaultMetadataStorage();
+        const allMetadataStorage = getMetadataArgsStorage();
 
         // filter the only metadata we need - those which are bind to the given table classes
         const allTableMetadatas = allMetadataStorage.tableMetadatas.filterByClasses(entityClasses);

src/metadata-storage/MetadataStorage.ts

@@ -11,12 +11,23 @@ import {JoinTableMetadata} from "../metadata/JoinTableMetadata";
 import {TargetMetadataCollection} from "../metadata/collection/TargetMetadataCollection";
 import {PropertyMetadataCollection} from "../metadata/collection/PropertyMetadataCollection";
 import {RelationsCountMetadata} from "../metadata/RelationsCountMetadata";
+import {RelationMetadataArgs} from "../metadata/args/RelationMetadataArgs";
+import {ColumnMetadataArgs} from "../metadata/args/ColumnMetadataArgs";
+import {RelationsCountMetadataArgs} from "../metadata/args/RelationsCountMetadataArgs";
+import {CompositeIndexMetadataArgs} from "../metadata/args/CompositeIndexMetadataArgs";
+import {IndexMetadataArgs} from "../metadata/args/IndexMetadataArgs";
+import {EntityListenerMetadataArgs} from "../metadata/args/EntityListenerMetadataArgs";
+import {TableMetadataArgs} from "../metadata/args/TableMetadataArgs";
+import {NamingStrategyMetadataArgs} from "../metadata/args/NamingStrategyMetadataArgs";
+import {EventSubscriberMetadataArgs} from "../metadata/args/EventSubscriberMetadataArgs";
+import {JoinTableMetadataArgs} from "../metadata/args/JoinTableMetadataArgs";
+import {JoinColumnMetadataArgs} from "../metadata/args/JoinColumnMetadataArgs";
 
 /**
  * Storage all metadatas of all available types: tables, fields, subscribers, relations, etc.
  * Each metadata represents some specifications of what it represents.
  */
-export class MetadataStorage {
+export class MetadataArgsStorage {
 
     // todo: type in function validation, inverse side function validation
     // todo: check on build for duplicate names, since naming checking was removed from MetadataStorage
@@ -27,17 +38,17 @@ export class MetadataStorage {
     // Properties
     // -------------------------------------------------------------------------
 
-    readonly tableMetadatas = new TargetMetadataCollection<TableMetadata>();
-    readonly namingStrategyMetadatas = new TargetMetadataCollection<NamingStrategyMetadata>();
-    readonly eventSubscriberMetadatas = new TargetMetadataCollection<EventSubscriberMetadata>();
-    readonly compositeIndexMetadatas = new TargetMetadataCollection<CompositeIndexMetadata>();
-    readonly columnMetadatas = new PropertyMetadataCollection<ColumnMetadata>();
-    readonly relationMetadatas = new PropertyMetadataCollection<RelationMetadata>();
-    readonly joinColumnMetadatas = new PropertyMetadataCollection<JoinColumnMetadata>();
-    readonly joinTableMetadatas = new PropertyMetadataCollection<JoinTableMetadata>();
-    readonly indexMetadatas = new PropertyMetadataCollection<IndexMetadata>();
-    readonly entityListenerMetadatas = new PropertyMetadataCollection<EntityListenerMetadata>();
-    readonly relationCountMetadatas = new PropertyMetadataCollection<RelationsCountMetadata>();
+    readonly tableMetadatas = new TargetMetadataCollection<TableMetadataArgs>();
+    readonly namingStrategyMetadatas = new TargetMetadataCollection<NamingStrategyMetadataArgs>();
+    readonly eventSubscriberMetadatas = new TargetMetadataCollection<EventSubscriberMetadataArgs>();
+    readonly compositeIndexMetadatas = new TargetMetadataCollection<CompositeIndexMetadataArgs>();
+    readonly columnMetadatas = new PropertyMetadataCollection<ColumnMetadataArgs>();
+    readonly relationMetadatas = new PropertyMetadataCollection<RelationMetadataArgs>();
+    readonly joinColumnMetadatas = new PropertyMetadataCollection<JoinColumnMetadataArgs>();
+    readonly joinTableMetadatas = new PropertyMetadataCollection<JoinTableMetadataArgs>();
+    readonly indexMetadatas = new PropertyMetadataCollection<IndexMetadataArgs>();
+    readonly entityListenerMetadatas = new PropertyMetadataCollection<EntityListenerMetadataArgs>();
+    readonly relationCountMetadatas = new PropertyMetadataCollection<RelationsCountMetadataArgs>();
 
     // -------------------------------------------------------------------------
     // Constructor

src/metadata/CompositeIndexMetadata.ts

@@ -1,7 +1,7 @@
 import {TargetMetadata} from "./TargetMetadata";
 import {NamingStrategyInterface} from "../naming-strategy/NamingStrategyInterface";
 import {EntityMetadata} from "./EntityMetadata";
-import {CompositeIndexOptions} from "./options/CompositeIndexOptions";
+import {CompositeIndexMetadataArgs} from "./args/CompositeIndexMetadataArgs";
 
 /**
  * This metadata interface contains all information about table's composite index.
@@ -49,16 +49,13 @@ export class CompositeIndexMetadata extends TargetMetadata {
     // Constructor
     // ---------------------------------------------------------------------
 
-    constructor(target: Function, 
-                name: string|undefined, 
-                columns: ((object: any) => any[])|string[],
-                options?: CompositeIndexOptions) {
-        super(target);
-        this._columns = columns;
-        if (name)
-            this._name = name;
-        if (options && options.unique)
-            this.isUnique = options.unique;
+    constructor(metadata: CompositeIndexMetadataArgs) {
+        super(metadata.target);
+        this._columns = metadata.columns;
+        if (metadata.name)
+            this._name = metadata.name;
+        if (metadata.options && metadata.options.unique)
+            this.isUnique = metadata.options.unique;
     }
 
     // ---------------------------------------------------------------------

src/metadata/EntityListenerMetadata.ts

@@ -1,5 +1,6 @@
 import {PropertyMetadata} from "./PropertyMetadata";
 import {EventListenerType} from "./types/EventListenerTypes";
+import {EntityListenerMetadataArgs} from "./args/EntityListenerMetadataArgs";
 
 /**
  * This metadata interface contains all information about some index on a field.
@@ -19,9 +20,9 @@ export class EntityListenerMetadata extends PropertyMetadata {
     // Constructor
     // ---------------------------------------------------------------------
 
-    constructor(target: Function, propertyName: string, type: EventListenerType) {
-        super(target, propertyName);
-        this.type = type;
+    constructor(metadata: EntityListenerMetadataArgs) {
+        super(metadata.target, metadata.propertyName);
+        this.type = metadata.type;
     }
 
 

src/metadata/EventSubscriberMetadata.ts

@@ -5,4 +5,8 @@ import {TargetMetadata} from "./TargetMetadata";
  */
 export class EventSubscriberMetadata extends TargetMetadata {
 
+    constructor(metadata: EventSubscriberMetadata) {
+        super(metadata.target);
+    }
+    
 }

src/metadata/IndexMetadata.ts

@@ -1,5 +1,6 @@
 import {PropertyMetadata} from "./PropertyMetadata";
 import {NamingStrategyInterface} from "../naming-strategy/NamingStrategyInterface";
+import {IndexMetadataArgs} from "./args/IndexMetadataArgs";
 
 /**
  * This metadata interface contains all information about some index on a field.
@@ -28,12 +29,11 @@ export class IndexMetadata extends PropertyMetadata {
     // Constructor
     // ---------------------------------------------------------------------
 
-    constructor(target: Function, propertyName: string, name?: string) {
-        super(target, propertyName);
+    constructor(metadata: IndexMetadataArgs) {
+        super(metadata.target, metadata.propertyName);
         
-        if (name)
+        if (metadata.name)
             this.name = name; // todo: if there is no name, then generate it (using naming strategy?)
     }
 
-
 }

src/metadata/JoinColumnMetadata.ts

@@ -3,6 +3,7 @@ import {JoinColumnOptions} from "./options/JoinColumnOptions";
 import {NamingStrategyInterface} from "../naming-strategy/NamingStrategyInterface";
 import {RelationMetadata} from "./RelationMetadata";
 import {ColumnMetadata} from "./ColumnMetadata";
+import {JoinColumnMetadataArgs} from "./args/JoinColumnMetadataArgs";
 
 /**
  */
@@ -35,15 +36,13 @@ export class JoinColumnMetadata extends PropertyMetadata {
     // Constructor
     // ---------------------------------------------------------------------
 
-    constructor(target: Function, 
-                propertyName: string, 
-                options: JoinColumnOptions) {
-        super(target, propertyName);
+    constructor(metadata: JoinColumnMetadataArgs) {
+        super(metadata.target, metadata.propertyName);
         
-        if (options.name)
-            this._name = options.name;
-        if (options.referencedColumnName)
-            this._referencedColumnName = options.referencedColumnName;
+        if (metadata.options.name)
+            this._name = metadata.options.name;
+        if (metadata.options.referencedColumnName)
+            this._referencedColumnName = metadata.options.referencedColumnName;
     }
 
     // ---------------------------------------------------------------------

src/metadata/JoinTableMetadata.ts

@@ -1,7 +1,7 @@
 import {PropertyMetadata} from "./PropertyMetadata";
-import {JoinTableOptions} from "./options/JoinTableOptions";
 import {RelationMetadata} from "./RelationMetadata";
 import {ColumnMetadata} from "./ColumnMetadata";
+import {JoinTableMetadataArgs} from "./args/JoinTableMetadataArgs";
 
 /**
  */
@@ -49,24 +49,24 @@ export class JoinTableMetadata extends PropertyMetadata {
     // Constructor
     // ---------------------------------------------------------------------
 
-    constructor(target: Function, propertyName: string, options: JoinTableOptions) {
-        super(target, propertyName);
+    constructor(metadata: JoinTableMetadataArgs) {
+        super(metadata.target, metadata.propertyName);
         
-        if (options.name)
-            this._name = options.name;
+        if (metadata.options.name)
+            this._name = metadata.options.name;
         
-        if (options.joinColumn) {
-            if (options.joinColumn.name)
-                this._joinColumnName = options.joinColumn.name;
-            if (options.joinColumn.referencedColumnName)
-                this._joinColumnReferencedColumnName = options.joinColumn.referencedColumnName;
+        if (metadata.options.joinColumn) {
+            if (metadata.options.joinColumn.name)
+                this._joinColumnName = metadata.options.joinColumn.name;
+            if (metadata.options.joinColumn.referencedColumnName)
+                this._joinColumnReferencedColumnName = metadata.options.joinColumn.referencedColumnName;
         }
         
-        if (options.inverseJoinColumn) {
-            if (options.inverseJoinColumn.name)
-                this._inverseJoinColumnName = options.inverseJoinColumn.name;
-            if (options.inverseJoinColumn.referencedColumnName)
-                this._inverseJoinColumnReferencedColumnName = options.inverseJoinColumn.referencedColumnName;
+        if (metadata.options.inverseJoinColumn) {
+            if (metadata.options.inverseJoinColumn.name)
+                this._inverseJoinColumnName = metadata.options.inverseJoinColumn.name;
+            if (metadata.options.inverseJoinColumn.referencedColumnName)
+                this._inverseJoinColumnReferencedColumnName = metadata.options.inverseJoinColumn.referencedColumnName;
         }
     }
 

src/metadata/NamingStrategyMetadata.ts

@@ -1,4 +1,5 @@
 import {TargetMetadata} from "./TargetMetadata";
+import {NamingStrategyMetadataArgs} from "./args/NamingStrategyMetadataArgs";
 
 /**
  * This metadata interface contains all information about naming strategy.
@@ -18,9 +19,9 @@ export class NamingStrategyMetadata extends TargetMetadata {
     // Constructor
     // ---------------------------------------------------------------------
 
-    constructor(target: Function, name: string) {
-        super(target);
-        this.name = name;
+    constructor(metadata: NamingStrategyMetadataArgs) {
+        super(metadata.target);
+        this.name = metadata.name;
     }
 
 }

src/metadata/RelationMetadata.ts

@@ -115,11 +115,6 @@ export class RelationMetadata extends PropertyMetadata {
     // Private Properties
     // ---------------------------------------------------------------------
 
-    /**
-     * Column name for this relation.
-     */
-    private _name: string;
-
     /**
      * The type of the field.
      */
@@ -140,8 +135,6 @@ export class RelationMetadata extends PropertyMetadata {
         
         if (args.inverseSideProperty)
             this._inverseSideProperty = args.inverseSideProperty;
-        if (args.options.name)
-            this._name = args.options.name;
         if (args.propertyType)
             this.propertyType = args.propertyType;
         if (args.options.cascadeInsert || args.options.cascadeAll)
@@ -163,8 +156,6 @@ export class RelationMetadata extends PropertyMetadata {
 
         if (!this._type)
             this._type = args.type;
-        if (!this._name)
-            this._name = args.propertyName;
     }
 
     // ---------------------------------------------------------------------
@@ -175,7 +166,7 @@ export class RelationMetadata extends PropertyMetadata {
         if (this.joinColumn && this.joinColumn.name)
             return this.joinColumn.name;
         
-        return this.namingStrategy ? this.namingStrategy.relationName(this._name) : this._name;
+        return this.namingStrategy ? this.namingStrategy.relationName(this.propertyName) : this.propertyName;
     }
     
     get referencedColumnName(): string {

src/metadata/RelationsCountMetadata.ts

@@ -1,4 +1,5 @@
 import {PropertyMetadata} from "./PropertyMetadata";
+import {RelationsCountMetadataArgs} from "./args/RelationsCountMetadataArgs";
 
 /**
  */
@@ -17,9 +18,9 @@ export class RelationsCountMetadata extends PropertyMetadata {
     // Constructor
     // ---------------------------------------------------------------------
 
-    constructor(target: Function, propertyName: string, relation: string|((object: any) => any)) {
-        super(target, propertyName);
-        this.relation = relation;
+    constructor(args: RelationsCountMetadataArgs) {
+        super(args.target, args.propertyName);
+        this.relation = args.relation;
     }
 
 }

src/metadata/TableMetadata.ts

@@ -1,5 +1,6 @@
 import {TargetMetadata} from "./TargetMetadata";
 import {EntityMetadata} from "./EntityMetadata";
+import {TableMetadataArgs} from "./args/TableMetadataArgs";
 
 /**
  * Table type.
@@ -38,15 +39,14 @@ export class TableMetadata extends TargetMetadata {
     // Constructor
     // ---------------------------------------------------------------------
 
-    constructor(target?: Function, name?: string, type: TableType = "regular") {
-        super(target);
-        
-        if (name)
-            this._name = name;
-        if (type)
-            this.tableType = type;
-    }
+    constructor(metadata: TableMetadataArgs) {
+        super(metadata.target);
 
+        this.tableType = metadata.type;
+        if (metadata.name)
+            this._name = name;
+    }
+    
     // ---------------------------------------------------------------------
     // Accessors
     // ---------------------------------------------------------------------

src/metadata/args/ColumnMetadataArgs.ts

@@ -9,12 +9,12 @@ export interface ColumnMetadataArgs {
     /**
      * Class to which this column is applied.
      */
-    target?: Function;
+    target: Function;
 
     /**
      * Class's property name to which this column is applied.
      */
-    propertyName?: string;
+    propertyName: string;
 
     /**
      * Class's property type (reflected) to which this column is applied.

src/metadata/args/CompositeIndexMetadataArgs.ts

@@ -0,0 +1,18 @@
+import {CompositeIndexOptions} from "../options/CompositeIndexOptions";
+
+/**
+ */
+export interface CompositeIndexMetadataArgs {
+
+    /**
+     * Class to which this column is applied.
+     */
+    target: Function;
+    
+    name: string|undefined,
+    
+    columns: ((object: any) => any[])|string[],
+    
+    options?: CompositeIndexOptions;
+    
+}

src/metadata/args/EntityListenerMetadataArgs.ts

@@ -0,0 +1,22 @@
+import {EventListenerType} from "../types/EventListenerTypes";
+
+/**
+ */
+export interface EntityListenerMetadataArgs {
+
+    /**
+     * Class to which this column is applied.
+     */
+    target: Function;
+
+    /**
+     * Class's property name to which this column is applied.
+     */
+    propertyName: string;
+
+    /**
+     * The type of the listener.
+     */
+    type: EventListenerType;
+    
+}

src/metadata/args/EventSubscriberMetadataArgs.ts

@@ -0,0 +1,10 @@
+/**
+ */
+export interface EventSubscriberMetadataArgs {
+
+    /**
+     * Class to which this subscriber is applied.
+     */
+    target: Function;
+    
+}

src/metadata/args/IndexMetadataArgs.ts

@@ -0,0 +1,14 @@
+/**
+ */
+export interface IndexMetadataArgs {
+
+    /**
+     * Class to which this column is applied.
+     */
+    target: Function;
+    
+    propertyName: string;
+    
+    name?: string;
+    
+}

src/metadata/args/JoinColumnMetadataArgs.ts

@@ -0,0 +1,23 @@
+import {JoinColumnOptions} from "../options/JoinColumnOptions";
+
+/**
+ * Constructor arguments for ColumnMetadata class.
+ */
+export interface JoinColumnMetadataArgs {
+
+    /**
+     * Class to which this column is applied.
+     */
+    target: Function;
+
+    /**
+     * Class's property name to which this column is applied.
+     */
+    propertyName: string;
+
+    /**
+     * Class's property type (reflected) to which this column is applied.
+     */
+    options: JoinColumnOptions;
+    
+}

src/metadata/args/JoinTableMetadataArgs.ts

@@ -0,0 +1,23 @@
+import {JoinTableOptions} from "../options/JoinTableOptions";
+
+/**
+ * Constructor arguments for ColumnMetadata class.
+ */
+export interface JoinTableMetadataArgs {
+
+    /**
+     * Class to which this column is applied.
+     */
+    target: Function;
+
+    /**
+     * Class's property name to which this column is applied.
+     */
+    propertyName: string;
+
+    /**
+     * Class's property type (reflected) to which this column is applied.
+     */
+    options: JoinTableOptions;
+    
+}

src/metadata/args/NamingStrategyMetadataArgs.ts

@@ -0,0 +1,13 @@
+/**
+ */
+export interface NamingStrategyMetadataArgs {
+
+    /**
+     */
+    target: Function;
+
+    /**
+     */
+    name: string;
+    
+}

src/metadata/args/RelationsCountMetadataArgs.ts

@@ -0,0 +1,20 @@
+import {ColumnOptions} from "../options/ColumnOptions";
+import {ColumnMode} from "../ColumnMetadata";
+
+/**
+ * Constructor arguments for ColumnMetadata class.
+ */
+export interface RelationsCountMetadataArgs {
+
+    /**
+     * Class to which this column is applied.
+     */
+    target: Function;
+
+    /**
+     * Class's property name to which this column is applied.
+     */
+    propertyName: string;
+    
+    relation: string|((object: any) => any);
+}

src/metadata/args/TableMetadataArgs.ts

@@ -0,0 +1,18 @@
+import {TableType} from "../TableMetadata";
+
+/**
+ */
+export interface TableMetadataArgs {
+
+    /**
+     */
+    target: Function;
+
+    /**
+     */
+    name?: string;
+
+    /**
+     */
+    type: TableType;
+}

src/metadata/args/TargetMetadataArgs.ts

@@ -0,0 +1,11 @@
+/**
+ * Constructor arguments for ColumnMetadata class.
+ */
+export interface ColumnMetadataArgs {
+
+    /**
+     * Class to which this column is applied.
+     */
+    target: Function;
+    
+}

src/metadata/collection/TargetMetadataCollection.ts

@@ -1,7 +1,7 @@
-import {TargetMetadata} from "../TargetMetadata";
 import {MetadataAlreadyExistsError} from "../../metadata-storage/error/MetadataAlreadyExistsError";
+import {TableMetadataArgs} from "../args/TableMetadataArgs";
 
-export class TargetMetadataCollection<T extends TargetMetadata> extends Array<T> {
+export class TargetMetadataCollection<T extends TableMetadataArgs> extends Array<T> {
     
     // -------------------------------------------------------------------------
     // Public Methods

src/metadata/options/RelationOptions.ts

@@ -5,11 +5,6 @@ import {OnDeleteType} from "../../metadata/ForeignKeyMetadata";
  */
 export interface RelationOptions {
 
-    /**
-     * Field name to be used in the database.
-     */
-    name?: string;
-
     /**
      * If set to true then it means that related object can be allowed to be inserted / updated / removed to the db.
      * This is option a shortcut if you would like to set cascadeInsert, cascadeUpdate and cascadeRemove to true.