fix: adapt seeder to new schema

src/commands/seed.command.ts

@@ -4,7 +4,7 @@ import { gray } from 'chalk'
 import { configureConnection, fetchConnection } from '../connection'
 import { Seeder } from '../seeder'
 import { useSeeders } from '../useSeeders'
-import { runSeeder } from '../runSeeder'
+import { Connection } from 'typeorm'
 
 interface SeedCommandArguments extends Arguments {
   root?: string
@@ -68,9 +68,10 @@ export class SeedCommand implements CommandModule {
     }
 
     // Get database connection and pass it to the seeder
+    let connection!: Connection
     spinner.start('Connecting to the database')
     try {
-      await fetchConnection()
+      connection = await fetchConnection()
       spinner.succeed('Database connected')
     } catch (error) {
       panic(spinner, error as Error, 'Database connection failed! Check your TypeORM config.')
@@ -80,7 +81,7 @@ export class SeedCommand implements CommandModule {
     for (const seeder of seeders) {
       spinner.start(`Executing ${seeder.constructor.name} Seeder`)
       try {
-        await runSeeder(seeder)
+        seeder.run(connection)
         spinner.succeed(`Seeder ${seeder.constructor.name} executed`)
       } catch (error) {
         panic(spinner, error as Error, `Could not run the seed ${seeder.constructor.name}!`)

src/index.ts

@@ -1,5 +1,5 @@
 export * from './connection'
-export * from './runSeeder'
+export * from './factory'
 export * from './seeder'
 export * from './types'
 export * from './useSeeders'

src/useSeeders.ts

@@ -1,6 +1,5 @@
-import { configureConnection, getConnectionOptions } from './connection'
+import { configureConnection, fetchConnection, getConnectionOptions } from './connection'
 import { SeederImportationError } from './errors/SeederImportationError'
-import { runSeeder } from './runSeeder'
 import { Seeder } from './seeder'
 import type { ConnectionConfiguration } from './types'
 import { calculateFilePaths } from './utils/fileHandling'
@@ -35,13 +34,14 @@ export async function useSeeders(
 
   let seedersImported: Seeder[]
   try {
-    seedersImported = await Promise.all(
-      seederFiles.map((seederFile) => import(seederFile).then((module) => module.default)),
-    ).then((elems) => elems.map((elem) => new elem()).filter((elem) => elem instanceof Seeder) as Seeder[])
+    seedersImported = await Promise.all(seederFiles.map((seederFile) => import(seederFile)))
+      .then((elementsImported) => elementsImported.flatMap((e) => Object.values(e)))
+      .then((elems) => elems.map((elem) => new elem()).filter((elem) => elem instanceof Seeder) as Seeder[])
 
     if (shouldExecuteSeeders) {
+      const connection = await fetchConnection()
       for (const seeder of seedersImported) {
-        await runSeeder(seeder)
+        seeder.run(connection)
       }
     }
   } catch (error: any) {

test/factory.test.ts

@@ -1,6 +1,5 @@
 import { Connection } from 'typeorm'
-import { configureConnection, fetchConnection } from '../src/connection'
-import { Factory } from '../src/factory'
+import { configureConnection, Factory, fetchConnection } from '../src'
 import { Pet } from './entities/Pet.entity'
 import { User } from './entities/User.entity'
 import { PetFactory } from './factories/Pet.factory'

test/seeders/User.seeder.ts

@@ -0,0 +1,8 @@
+import { Seeder } from '../../src'
+import { UserFactory } from '../factories/User.factory'
+
+export class UserSeeder extends Seeder {
+  async run() {
+    await new UserFactory().createMany(10)
+  }
+}

test/useSeeders/useSeedersWithError.spec.ts

@@ -0,0 +1,12 @@
+import { useSeeders } from '../../src'
+import { SeederImportationError } from '../../src/errors/SeederImportationError'
+
+describe(useSeeders, () => {
+  test.only(`Should throw ${SeederImportationError.name}`, async () => {
+    jest.mock('../seeders/User.seeder.ts', () => {
+      throw new Error('Error')
+    })
+
+    expect(useSeeders()).rejects.toThrowError(SeederImportationError)
+  })
+})

test/useSeeders/useSeedersWithMultipleSeeders.spec.ts

@@ -0,0 +1,11 @@
+import { useSeeders } from '../../src/useSeeders'
+
+describe(useSeeders, () => {
+  test('Should import all seeders', async () => {
+    const seeders = await useSeeders()
+
+    expect(seeders).toHaveLength(1)
+    expect(seeders[0].constructor.name).toBe('UserSeeder')
+  })
+})
+

test/useSeeders/useSeedersWithSingleSeeder.test.ts

@@ -0,0 +1,23 @@
+import { useSeeders } from '../../src/useSeeders'
+import { Seeder } from '../../src/seeder'
+
+describe(useSeeders, () => {
+  const mockFn = jest.fn()
+
+  test('Should import one seeder and execute it', async () => {
+    jest.mock('../seeders/User.seeder.ts', () => {
+      return {
+        __esModule: true,
+        default: class Test extends Seeder {
+          async run() {
+            mockFn()
+          }
+        },
+      }
+    })
+    const seeders = await useSeeders(true, ['test/**/User.seeder.ts'])
+
+    expect(seeders).toHaveLength(1)
+    expect(mockFn).toHaveBeenCalledTimes(1)
+  })
+})