refactor the new seed

Author: hirsch88

src/database/seeds/CreatePets.ts

@@ -1,23 +1,23 @@
 import { Connection } from 'typeorm';
 
-import { Factory, Seed } from '../../lib/seed/types';
+import { Pet } from '../../../src/api/models/Pet';
+import { User } from '../../../src/api/models/User';
+import { Factory, Seed, times } from '../../lib/seed';
 
-// import { Pet } from '../../../src/api/models/Pet';
-// import { User } from '../../../src/api/models/User';
 export class CreatePets implements Seed {
 
     public async seed(factory: Factory, connection: Connection): Promise<any> {
         console.log('CreatePets');
 
         // const connection = await factory.getConnection();
-        // const em = connection.createEntityManager();
+        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);
-        // });
+        await times(10, async (n) => {
+            const pet = await factory<Pet, undefined>(Pet as any)().seed();
+            const user = await factory<User, undefined>(User as any)().make();
+            user.pets = [pet];
+            await em.save(user);
+        });
     }
 
 }

src/database/seeds/CreateUsers.ts

@@ -1,16 +1,15 @@
 import { Connection } from 'typeorm/connection/Connection';
 
+import { User } from '../../../src/api/models/User';
 import { Factory, Seed } from '../../lib/seed/types';
 
-// import { User } from '../../../src/api/models/User';
 export class CreateUsers implements Seed {
 
     public async seed(factory: Factory, connection: Connection): Promise<any> {
         console.log('CreateUsers');
 
-        // await factory
-        //     .get(User)
-        //     .createMany(10);
+        await factory(User)()
+            .seedMany(10);
     }
 
 }

src/lib/seed/EntityFactory.ts

@@ -4,6 +4,9 @@ import { Connection } from 'typeorm/connection/Connection';
 import { FactoryFunction } from './types';
 import { isPromiseLike } from './utils';
 
+/**
+ * EntityFactory ...
+ */
 export class EntityFactory<Entity, Settings> {
 
     private mapFunction: (entity: Entity) => Promise<Entity>;
@@ -19,11 +22,18 @@ export class EntityFactory<Entity, Settings> {
     // Public API
     // -------------------------------------------------------------------------
 
+    /**
+     * This fucntion is used to alter the generated values of entity, before it
+     * is persist into the database
+     */
     public map(mapFunction: (entity: Entity) => Promise<Entity>): EntityFactory<Entity, Settings> {
         this.mapFunction = mapFunction;
         return this;
     }
 
+    /**
+     * Make generate a new entity, but does not persist it
+     */
     public async make(): Promise<Entity> {
         if (this.factory) {
             let entity = await this.resolveEntity(this.factory(Faker, this.settings));
@@ -35,6 +45,9 @@ export class EntityFactory<Entity, Settings> {
         throw new Error('Could not found entity');
     }
 
+    /**
+     * Seed persist and generates a given entity
+     */
     public async seed(): Promise<Entity> {
         const connection: Connection = (global as any).seeder.connection;
         if (connection) {

src/lib/seed/cli.ts

@@ -5,12 +5,11 @@ import * as path from 'path';
 import { loadEntityFactories } from './';
 import { getConnection } from './connection';
 import { loadSeeds } from './importer';
-import { runSeeder, setConnection } from './index';
-import { SeedConstructor } from './types';
+import { runSeed, setConnection } from './index';
 
 // Cli helper
 commander
-    .version('0.0.0')
+    .version('1.0.0')
     .description('Run database seeds of your project')
     .option('-L, --logging', 'enable sql query logging')
     .option('--factories <path>', 'add filepath for your factories')
@@ -91,8 +90,4 @@ const handleError = (error) => {
     process.exit(1);
 };
 
-const runSeed = async (seedClass: SeedConstructor): Promise<void> => {
-    await runSeeder(seedClass);
-};
-
 run();

src/lib/seed/importer.ts

@@ -12,15 +12,9 @@ const loadFiles =
         (pathToFolder: string) =>
             (successFn: (files: string[]) => void) =>
                 (failedFn: (error: any) => void) => {
-                    glob(path.join(process.cwd(), pathToFolder, filePattern), (error: any, files: string[]) => {
-                        if (error) {
-                            return failedFn(error);
-                        }
-                        successFn(files);
-                    });
-                    // error
-                    //     ? failedFn(error)
-                    //     : successFn(files));
+                    glob(path.join(process.cwd(), pathToFolder, filePattern), (error: any, files: string[]) => error
+                        ? failedFn(error)
+                        : successFn(files));
                 };
 
 const loadFactoryFiles = loadFiles('**/*Factory{.js,.ts}');
@@ -40,9 +34,6 @@ export const loadEntityFactories = (pathToFolder: string): Promise<string[]> =>
 
 export const loadSeeds = (pathToFolder: string): Promise<string[]> => {
     return new Promise((resolve, reject) => {
-        loadFiles('**/*{.js,.ts}')(pathToFolder)(files => {
-            // TODO: load seeds
-            resolve(files);
-        })(reject);
+        loadFiles('**/*{.js,.ts}')(pathToFolder)(resolve)(reject);
     });
 };

src/lib/seed/index.ts

@@ -2,14 +2,18 @@ import 'reflect-metadata';
 import { Connection, ObjectType } from 'typeorm';
 
 import { EntityFactory } from './EntityFactory';
-import { EntityFactoryDefinition, FactoryFunction, SeedConstructor } from './types';
+import {
+    EntityConstructor, EntityFactoryDefinition, FactoryFunction, SeedConstructor
+} from './types';
 import { getNameOfClass } from './utils';
 
 // -------------------------------------------------------------------------
 // Handy Exports
 // -------------------------------------------------------------------------
 
 export * from './importer';
+export { Factory, Seed } from './types';
+export { times } from './utils';
 
 // -------------------------------------------------------------------------
 // Types & Variables
@@ -20,23 +24,32 @@ export * from './importer';
     entityFactories: new Map<string, EntityFactoryDefinition<any, any>>(),
 };
 
-// -------------------------------------------------------------------------
-// Util functions
-// -------------------------------------------------------------------------
-
 // -------------------------------------------------------------------------
 // Facade functions
 // -------------------------------------------------------------------------
 
+/**
+ * Adds the typorm connection to the seed options
+ */
 export const setConnection = (connection: Connection) => (global as any).seeder.connection = connection;
 
+/**
+ * Returns the typorm connection from our seed options
+ */
 export const getConnection = () => (global as any).seeder.connection;
 
+/**
+ * Defines a new entity factory
+ */
 export const define = <Entity, Settings>(entity: ObjectType<Entity>, factoryFn: FactoryFunction<Entity, Settings>) => {
     (global as any).seeder.entityFactories.set(getNameOfClass(entity), { entity, factory: factoryFn });
 };
 
-export const factory = <Entity, Settings>(entity: any) => (settings?: Settings) => {
+
+/**
+ * Gets a defined entity factory and pass the settigns along to the entity factory function
+ */
+export const factory = <Entity, Settings>(entity: EntityConstructor<Entity>) => (settings?: Settings) => {
     const name = getNameOfClass(entity);
     const entityFactoryObject = (global as any).seeder.entityFactories.get(name);
     return new EntityFactory<Entity, Settings>(
@@ -47,22 +60,10 @@ export const factory = <Entity, Settings>(entity: any) => (settings?: Settings)
     );
 };
 
-export const seed = async <Entity, Settings>(entityFactory: EntityFactory<Entity, Settings>): Promise<Entity> => {
-    const connection: Connection = (global as any).seeder.connection;
-    if (connection) {
-        const em = connection.createEntityManager();
-        try {
-            const entity = await entityFactory.make();
-            return await em.save<Entity>(entityFactory.entity, entity);
-        } catch (error) {
-            throw new Error('Could not save entity');
-        }
-    } else {
-        throw new Error('No db connection is given');
-    }
-};
-
-export const runSeeder = async <T>(seederConstructor: SeedConstructor): Promise<T> => {
+/**
+ * Runs a seed class
+ */
+export const runSeed = async <T>(seederConstructor: SeedConstructor): Promise<T> => {
     const seeder = new seederConstructor();
     return seeder.seed(factory, getConnection());
 };

src/lib/seed/make.ts

@@ -3,19 +3,34 @@ import { Connection, ObjectType } from 'typeorm';
 
 import { EntityFactory } from './EntityFactory';
 
+/**
+ * FactoryFunction is the fucntion, which generate a new filled entity
+ */
 export type FactoryFunction<Entity, Settings> = (faker: typeof Faker, settings?: Settings) => Entity;
 
+/**
+ * Factory gets the EntityFactory to the given Entity and pass the settings along
+ */
 export type Factory = <Entity, Settings>(entity: Entity) => (settings?: Settings) => EntityFactory<Entity, Settings>;
 
-export interface EntityFactoryDefinition<Entity, Settings> {
-    entity: ObjectType<Entity>;
-    factory: FactoryFunction<Entity, Settings>;
-}
-
+/**
+ * Seed are the class to create some data. Those seed are run by the cli.
+ */
 export interface Seed {
     seed(factory: Factory, connection: Connection): Promise<any>;
 }
 
+/**
+ * Constructor of the seed class
+ */
 export interface SeedConstructor {
     new(): Seed;
 }
+
+/**
+ * Value of our EntityFactory state
+ */
+export interface EntityFactoryDefinition<Entity, Settings> {
+    entity: ObjectType<Entity>;
+    factory: FactoryFunction<Entity, Settings>;
+}

src/lib/seed/types.ts

@@ -1,7 +1,21 @@
-// -------------------------------------------------------------------------
-// Util functions
-// -------------------------------------------------------------------------
-
+/**
+ * Returns the name of a class
+ */
 export const getNameOfClass = (c: any): string => new c().constructor.name;
 
+/**
+ * Checks if the given argument is a promise
+ */
 export const isPromiseLike = (o: any): boolean => !!o && (typeof o === 'object' || typeof o === 'function') && typeof o.then === 'function';
+
+/**
+ * Times repeats a function n times
+ */
+export const times = async <TResult>(n: number, iteratee: (index: number) => Promise<TResult>): Promise<TResult[]> => {
+    const rs = [] as TResult[];
+    for (let i = 0; i < n; i++) {
+        const r = await iteratee(i);
+        rs.push(r);
+    }
+    return rs;
+};