Adjust seed logic to typeorm

Author: hirsch88

README.md

@@ -142,7 +142,8 @@ All script are defined in the package.json file, but the most important ones are
 
 ### Database Migration
 
-- Run `./node_modules/.bin/typeorm create -n <migration-file-name>` to create a new migration file.
+- Run `typeorm migrations:create -n <migration-file-name>` to create a new migration file.
+- Try `typeorm -h` to see more useful cli commands like generating migration out of your models.
 - To migrate your database run `npm start db.migrate`.
 - To revert your latest migration run `npm start db.revert`.
 - Drops the complete database schema `npm start db.drop`.
@@ -267,19 +268,44 @@ factory.define(User, (faker: typeof Faker) => {
 });
 ```
 
-This is a nested example for a factory to get the foreign key of the other entity.
+This can be used to pass some dynamic value into the factory.
 
 ```typescript
 factory.define(Pet, (faker: typeof Faker, args: any[]) => {
     const type = args[0];
     return {
         name: faker.name.firstName(),
-        type: type || 'dog',
-        userId: factory.get(User).returning('id')
+        type: type || 'dog'
     };
 });
 ```
 
+To deal with relations you can use the entity manager like this.
+
+```typescript
+import { SeedsInterface, FactoryInterface, times } from '../../lib/seeds';
+import { Pet } from '../../../src/api/models/Pet';
+import { User } from '../../../src/api/models/User';
+
+export class CreatePets implements SeedsInterface {
+
+    public async seed(factory: FactoryInterface): Promise<any> {
+        const connection = await factory.getConnection();
+        const em = connection.createEntityManager();
+
+        await times(10, async (n) => {
+            // This creates a pet in the database
+            const pet = await factory.get(Pet).create();
+            // This only returns a entity with fake data
+            const user = await factory.get(User).make();
+            user.pets = [pet];
+            await em.save(user);
+        });
+    }
+
+}
+```
+
 ### 2. Create a seed file
 
 The seeds files define how much and how the data are connected with each other. The files will be executed alphabetically.

src/database/factories/PetFactory.ts

@@ -0,0 +1,20 @@
+import * as Faker from 'faker';
+import { Factory } from '../../lib/seeds';
+import { Pet } from '../../../src/api/models/Pet';
+// import { User } from '../../../src/api/models/User';
+
+const factory = Factory.getInstance();
+
+
+/**
+ * Pet factory
+ */
+factory.define(Pet, (faker: typeof Faker) => {
+    const gender = faker.random.number(1);
+    const name = faker.name.firstName(gender);
+
+    const pet = new Pet();
+    pet.name = name;
+    pet.age = faker.random.number();
+    return pet;
+});

src/database/migrations/1511105183653-CreateUserTable.ts

@@ -8,12 +8,12 @@ export class CreateUserTable1511105183653 implements MigrationInterface {
                 \`id\` varchar(255) NOT NULL PRIMARY KEY,
                 \`first_name\` varchar(255) NOT NULL,
                 \`last_name\` varchar(255) NOT NULL,
-                \`email\` varchar(255) NOT NULL) ENGINE=InnoDB`
+                \`email\` varchar(255) NOT NULL) ENGINE=InnoDB;`
         );
     }
 
     public async down(queryRunner: QueryRunner): Promise<any> {
-        await queryRunner.query(`DROP TABLE \`user\``);
+        await queryRunner.query(`DROP TABLE \`user\`;`);
     }
 
 }

src/database/migrations/1512663524808-CreatePetTable.ts

@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CreatePetTable1512663524808 implements MigrationInterface {
+
+    public async up(queryRunner: QueryRunner): Promise<any> {
+        await queryRunner.query(`
+            CREATE TABLE \`pet\` (
+                \`id\` varchar(255) NOT NULL PRIMARY KEY,
+                \`name\` varchar(255) NOT NULL,
+                \`age\` int(11) NOT NULL,
+                \`userId\` varchar(255)) ENGINE=InnoDB;`
+        );
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<any> {
+        await queryRunner.query(`DROP TABLE \`pet\`;`);
+    }
+
+}

src/database/migrations/1512663990063-AddUserRelationToPetTable.ts

@@ -0,0 +1,22 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddUserRelationToPetTable1512663990063 implements MigrationInterface {
+
+    public async up(queryRunner: QueryRunner): Promise<any> {
+        await queryRunner.query(`
+            ALTER TABLE \`pet\`
+                ADD CONSTRAINT \`fk_user_pet\`
+                FOREIGN KEY (\`userId\`)
+                REFERENCES \`user\`(\`id\`);`
+        );
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<any> {
+        await queryRunner.query(`
+        ALTER TABLE \`pet\`
+            DROP FOREIGN KEY \`fk_user_pet\`;`
+        );
+    }
+
+}
+

src/database/seeds/0000-CreateUsers.ts

@@ -7,7 +7,7 @@ export class CreateUsers implements SeedsInterface {
     public async seed(factory: FactoryInterface): Promise<any> {
         await factory
             .get(User)
-            .create(1);
+            .create();
     }
 
 }

src/database/seeds/0001-CreatePets.ts

@@ -0,0 +1,20 @@
+import { SeedsInterface, FactoryInterface, times } from '../../lib/seeds';
+import { Pet } from '../../../src/api/models/Pet';
+import { User } from '../../../src/api/models/User';
+
+
+export class CreatePets implements SeedsInterface {
+
+    public async seed(factory: FactoryInterface): Promise<any> {
+        const connection = await factory.getConnection();
+        const em = connection.createEntityManager();
+
+        await times(10, async (n) => {
+            const pet = await factory.get(Pet).create();
+            const user = await factory.get(User).make();
+            user.pets = [pet];
+            await em.save(user);
+        });
+    }
+
+}

src/lib/seeds/BluePrint.ts

@@ -8,5 +8,5 @@ import { ObjectType } from 'typeorm';
 export class BluePrint<Entity> {
     constructor(
         public EntityClass: ObjectType<Entity>,
-        public callback: (faker: typeof Faker, args: any[]) => any) { }
+        public create: (faker: typeof Faker, args: any[]) => Entity) { }
 }

src/lib/seeds/EntityFactory.ts

@@ -1,54 +1,51 @@
 import * as Faker from 'faker';
-import { Connection } from 'typeorm';
+import { Connection } from 'typeorm/connection/Connection';
 import { EntityFactoryInterface } from './EntityFactoryInterface';
 import { BluePrint } from './BluePrint';
-import { getConnection } from './connection';
 
 
 export class EntityFactory<Entity> implements EntityFactoryInterface<Entity> {
 
-    private connection: Connection | undefined;
     private identifier = 'id';
     private eachFn: (obj: any, faker: typeof Faker) => Promise<any>;
 
     constructor(
         private faker: typeof Faker,
+        private connection: Connection,
         private blueprint: BluePrint<Entity>,
         private args: any[]) { }
 
-    public returning(identifier: string): EntityFactory<Entity> {
-        this.identifier = identifier;
-        return this;
-    }
-
     public each(iterator: (entity: Entity, faker: typeof Faker) => Promise<any>): EntityFactory<Entity> {
         this.eachFn = iterator;
         return this;
     }
 
-    public async create(amount: number = 1): Promise<Entity | Entity[] | undefined> {
-        this.connection = await getConnection();
-        if (this.connection) {
-            const results: Entity[] = [];
-            for (let i = 0; i < amount; i++) {
-                const entity = await this.build();
+    public async make(): Promise<Entity> {
+        return await this.makeEntity(this.blueprint.create(this.faker, this.args));
+    }
+
+    public async create(): Promise<Entity> {
+        const entity = await this.build();
+        if (typeof this.eachFn === 'function') {
+            await this.eachFn(entity, this.faker);
+        }
+        return entity;
+    }
+
+    public async createMany(amount: number): Promise<Entity[]> {
+        const results: Entity[] = [];
+        for (let i = 0; i < amount; i++) {
+            const entity = await this.create();
+            if (entity) {
                 results.push(entity);
-                if (typeof this.eachFn === 'function') {
-                    await this.eachFn(entity, this.faker);
-                }
-            }
-            await this.connection.close();
-            if (amount === 1) {
-                return results[0];
             }
-            return results;
         }
-        return;
+        return results;
     }
 
     private async build(): Promise<any> {
         if (this.connection) {
-            const entity = await this.makeEntity(this.blueprint.callback(this.faker, this.args));
+            const entity = await this.make();
             const em = this.connection.createEntityManager();
             try {
                 return await em.save(this.blueprint.EntityClass, entity);

src/lib/seeds/EntityFactoryInterface.ts

@@ -1,18 +1,23 @@
 import * as Faker from 'faker';
 
+
 /**
  * EntityFactoryInterface is the one we use in our seed files.
  * This will be returne of the main factory's get method.
  */
 export interface EntityFactoryInterface<Entity> {
     /**
-     * Creates an amount (default 1) of the defined entity.
+     * Creates a entity with faked data, but not persisted to the database.
      */
-    create(amount: number): Promise<Entity | Entity[] | undefined>;
+    make(): Promise<Entity>;
     /**
-     * Returns the identifier of the created entity.
+     * Creates a new faked entity in the database.
+     */
+    create(): Promise<Entity>;
+    /**
+     * Creates an amount (default 1) of the defined entity.
      */
-    returning(identifier: string): EntityFactoryInterface<Entity>;
+    createMany(amount: number): Promise<Entity[] | undefined>;
     /**
      * This is called after creating a enity to the database. Use this to
      * create other seeds but combined with this enitiy.