Seed entity with lazy relations

given following model:

```typescript
@entity(User.TABLE_NAME)
export class User {

    public static readonly TABLE_NAME = 'user';

    @PrimaryGeneratedColumn()
    public id: number;

    @column({
        name: 'first_name',
        nullable: false,
    })
    public firstName: string;

    @column({
        name: 'last_name',
        nullable: false,
    })
    public lastName: string;

    @column({
        name: 'email',
        nullable: false,
        unique: true,
    })
    public email: string;

    @column({
        name: 'password',
        nullable: false,
    })
    public password: string;

    @manytomany(type => Authority, authority => authority.users)
    @jointable({ name: 'user_authority' })
    public authorities: Promise<Authority[]>;
}
```

To create a new user entity you need to assign a promise to the entity, but to save you need to pass the authority object directly as mentioned here: typeorm/typeorm#1180 (comment)

```typescript
/**
 * User factory
 */
factory.define(User, (faker: typeof Faker, args: any[]) => {
    const gender = faker.random.number(1);
    const firstName = faker.name.firstName(gender);
    const lastName = faker.name.lastName(gender);
    const email = faker.internet.email(firstName, lastName);
    const authority = args[0] as Authority;

    const user = new User();
    user.firstName = firstName;
    user.lastName = lastName;
    user.email = email;
    user.password = env.admin.password;
    user.authorities = Promise.resolve([authority]);
    return user;
});
````

Author: Fabricio Vergara

src/lib/seeds/EntityFactory.ts

@@ -71,6 +71,10 @@ export class EntityFactory<Entity> implements EntityFactoryInterface<Entity> {
     private async makeEntity(entity: Entity): Promise<Entity> {
         for (const attribute in entity) {
             if (entity.hasOwnProperty(attribute)) {
+                if (this.isPromiseLike(typeof entity[attribute])) {
+                    entity[attribute] = await entity[attribute];
+                }
+                
                 if (typeof entity[attribute] === 'object' && entity[attribute] instanceof EntityFactory) {
                     const subEntityFactory = entity[attribute];
                     const subEntity = await (subEntityFactory as any).build();
@@ -81,4 +85,7 @@ export class EntityFactory<Entity> implements EntityFactoryInterface<Entity> {
         return entity;
     }
 
+    private isPromiseLike(object: any): boolean {
+        return object && typeof object.then === 'function';
+    }
 }