feat: adapt use seeders to new structure

BREAKING CHANGE `useSeeders` change its definition and is now incompatible with previous version

src/connection/getConnectionOptions.ts

@@ -1,4 +1,5 @@
 import { ConnectionOptionsReader } from 'typeorm'
+import { DefaultSeederNotDefinedError } from '../errors/DefaultSeederNotDefinedError'
 import type { ConnectionOptions } from '../types'
 import { ConnectionConfigurationManager } from './ConnectionConfigurationManager'
 
@@ -11,10 +12,17 @@ export async function getConnectionOptions(): Promise<ConnectionOptions> {
 
   const options = (await connectionReader.get(connection)) as ConnectionOptions
 
-  const seedersFromEnv = process.env.TYPEORM_SEEDING_SEEDS
+  const seedersFromEnv = process.env.TYPEORM_SEEDING_SEEDERS
+  const defaultSeederFromEnv = process.env.TYPEORM_SEEDING_DEFAULT_SEEDER
+  const defaultSeeder = defaultSeederFromEnv || options.defaultSeeder
+
+  if (!defaultSeeder) {
+    throw new DefaultSeederNotDefinedError()
+  }
 
   return {
     ...options,
     seeders: seedersFromEnv ? [seedersFromEnv] : options.seeders || [],
+    defaultSeeder,
   }
 }

src/errors/DefaultSeederNotDefinedError.ts

@@ -0,0 +1,5 @@
+export class DefaultSeederNotDefinedError extends Error {
+  constructor() {
+    super(`Default seeder is not defined.`)
+  }
+}

src/seeder.ts

@@ -1,5 +1,12 @@
 import type { Connection } from 'typeorm'
+import type { ClassConstructor } from './types'
 
 export abstract class Seeder {
   abstract run(connection: Connection): Promise<void>
+
+  protected async call(connection: Connection, seeders: ClassConstructor<Seeder>[]): Promise<void> {
+    for (const seeder of seeders) {
+      await new seeder().run(connection)
+    }
+  }
 }

src/types.ts

@@ -1,12 +1,10 @@
 import type { ConnectionOptions as TypeORMConnectionOptions } from 'typeorm'
 
-/**
- * Constructor of the seed class
- */
 export type ClassConstructor<T> = new () => T
 
 export type ConnectionOptions = TypeORMConnectionOptions & {
   seeders: string[]
+  defaultSeeder: string
 }
 
 export type ConnectionConfiguration = {

src/useSeeders.ts

@@ -1,52 +1,23 @@
-import { configureConnection, fetchConnection, getConnectionOptions } from './connection'
-import { SeederImportationError } from './errors/SeederImportationError'
+import { configureConnection, fetchConnection } from './connection'
 import { Seeder } from './seeder'
-import type { ConnectionConfiguration } from './types'
-import { calculateFilePaths } from './utils/fileHandling'
+import type { ClassConstructor, ConnectionConfiguration } from './types'
 
+export async function useSeeders(entrySeeders: ClassConstructor<Seeder> | ClassConstructor<Seeder>[]): Promise<void>
 export async function useSeeders(
-  executeSeeders?: boolean,
-  options?: Partial<ConnectionConfiguration>,
-): Promise<Seeder[]>
-export async function useSeeders(
-  executeSeeders?: boolean,
-  seeders?: string[],
-  options?: Partial<ConnectionConfiguration>,
-): Promise<Seeder[]>
+  entrySeeders: ClassConstructor<Seeder> | ClassConstructor<Seeder>[],
+  customOptions: Partial<ConnectionConfiguration>,
+): Promise<void>
 
 export async function useSeeders(
-  executeSeeders?: boolean,
-  seedersOrOptions?: string[] | Partial<ConnectionConfiguration>,
-  options?: Partial<ConnectionConfiguration>,
-) {
-  const shouldExecuteSeeders = Boolean(executeSeeders)
-  const seeders = Array.isArray(seedersOrOptions) ? seedersOrOptions : undefined
-  const customOptions = Array.isArray(seedersOrOptions) ? options : seedersOrOptions
+  entrySeeders: ClassConstructor<Seeder> | ClassConstructor<Seeder>[],
+  customOptions?: Partial<ConnectionConfiguration>,
+): Promise<void> {
+  if (customOptions) configureConnection(customOptions)
 
-  configureConnection(customOptions)
-  const option = await getConnectionOptions()
+  const connection = await fetchConnection()
 
-  let seederFiles = calculateFilePaths(option.seeders)
-  if (seeders) {
-    const seedersDesired = calculateFilePaths(seeders)
-    seederFiles = seederFiles.filter((factoryFile) => seedersDesired.includes(factoryFile))
+  const seeders = Array.isArray(entrySeeders) ? entrySeeders : [entrySeeders]
+  for (const seeder of seeders) {
+    await new seeder().run(connection)
   }
-
-  let seedersImported: Seeder[]
-  try {
-    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) {
-        seeder.run(connection)
-      }
-    }
-  } catch (error: any) {
-    throw new SeederImportationError(error.message)
-  }
-
-  return seedersImported
 }