Seeders

Why Seeders Are Used

Seeders are tools that populate a database with sample data. They are especially useful in testing and development environments to help developers and testers work with predictable and consistent data. Here are the main reasons why we use seeders in our projects:

• Testing: Seeders provide a reliable starting point with predefined data. This ensures that tests are repeatable and don’t rely on random data each time.
• Development: They provide developers with ready-made data to interact with, making it easier to test features and see how the application behaves with actual data.
• Automation: Seeders automate the database setup process, avoiding the need to create data manually. This is especially useful for larger projects where creating data by hand would be time-consuming.

With seeders, you can set up a controlled environment where you know exactly what data is in the database, allowing you to better predict and understand application behavior.

The Abstract Seeder

The AbstractSeeder class is a general-purpose seeder that can be extended to create seeders for different entities, like UserSeeder. It provides a base for implementing common functionality, such as saving entities to the database and checking for required relationships.

export abstract class AbstractSeeder<T extends ObjectLiteral> {
  protected requiredRelations: string[] = []

  protected constructor(
    protected repository: Repository<T>
  ) {}

  protected checkRequiredRelations(entity: T): void {
    for (const relation of this.requiredRelations) {
      if ((entity)[relation] === undefined) {
        throw new Error(`Missing required relation: ${relation}`)
      }
    }
  }

  public async seedOne(entity: T): Promise<T> {
    this.checkRequiredRelations(entity)
    return await this.seed(entity)
  }

  public async seedMany(entities: T[]): Promise<T[]> {
    for (const entity of entities) {
      this.checkRequiredRelations(entity)
    }
    return await this.repository.save(entities)
  }

  protected async seed(entity: T): Promise<T> {
    return await this.repository.save(entity)
  }
}

Implementing The Abstract Seeder (UserSeeder example)

If we are writing tests for a User Module, we might need a UserSeeder to have some initial data to run the tests against. We can create a UserSeerder by implementing the AbstractSeeder.

export class UserSeeder extends AbstractSeeder<User> {
  constructor (
    manager: EntityManager
  ) {
    super(new UserRepository(manager))
  }

  protected async seed (user: User): Promise<User> {
    user.password = await bcrypt.hash(user.password, 10)

    return await super.seed(user)
  }
}

In our tests, we can then simple seed a single user (or multiple users) with a speficic goal. For example, we might need an admin user, to test against certain permissions.

const adminUser = await this.userSeeder.seedOne(
  new UserEntityBuilder()
    .withEmail(randomUUID() + '@mail.com')
    .withRole(adminRole)
    .build()
)

We can now use this adminUser in our tests to validate certain test-cases.