Configuration

Complete reference for all FactoryModule.forRoot() and forRootAsync() configuration options.

The FactoryModule supports both static configuration via forRoot() and dynamic configuration via forRootAsync(). The module is registered globally -- you only need to import it once in your root module, and FactoryService becomes available everywhere through dependency injection.

Static Configuration (forRoot)

Use forRoot() when your configuration values are known at compile time:

import { Module } from "@nestjs/common";
import { FactoryModule } from "@nestbolt/factory";
import { UserFactory } from "./factories/user.factory";
import { PostFactory } from "./factories/post.factory";
import { DatabaseSeeder } from "./seeders/database.seeder";

@Module({
  imports: [
    FactoryModule.forRoot({
      factories: [UserFactory, PostFactory],
      seeders: [DatabaseSeeder],
      seed: 12345,
    }),
  ],
})
export class AppModule {}

Calling forRoot() with no arguments is also valid -- factories and seeders default to empty arrays:

FactoryModule.forRoot();

Async Configuration (forRootAsync)

Use forRootAsync() when configuration depends on other providers, such as a ConfigService:

import { Module } from "@nestjs/common";
import { ConfigModule, ConfigService } from "@nestjs/config";
import { FactoryModule } from "@nestbolt/factory";
import { UserFactory } from "./factories/user.factory";
import { PostFactory } from "./factories/post.factory";

@Module({
  imports: [
    ConfigModule.forRoot(),
    FactoryModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        factories: [UserFactory, PostFactory],
        seed: config.get<number>("FAKER_SEED"),
      }),
    }),
  ],
})
export class AppModule {}

forRootAsync Options

Property	Type	Description
`imports`	`any[]`	Modules to import (e.g., `[ConfigModule]`)
`inject`	`any[]`	Providers to inject into `useFactory`
`useFactory`	`(...args) => FactoryModuleOptions \| Promise<FactoryModuleOptions>`	Factory function that returns the configuration. Can be async.

Configuration Options Reference

factories

factories: [UserFactory, PostFactory];

An array of factory classes to register. Each class must extend BaseFactory<T>. Registered factories can be used via factoryService.use(FactoryClass).

If a factory class is not included in this array, calling use() with it will throw a FactoryNotRegisteredException.

Defaults to [] (empty array).

seeders

seeders: [DatabaseSeeder, UserSeeder];

An array of seeder classes to register. Each class must implement the Seeder interface. When factoryService.seed() is called, all registered seeders are executed in order of their order property (lowest first).

Defaults to [] (empty array).

seed

seed: 12345;

An optional numeric seed passed to faker.seed(). When set, Faker produces the same data on every run, making your factories and seeders deterministic. This is useful for:

Snapshot testing -- assertions against specific generated values.
Reproducible bug reports -- re-create the exact data that triggered an issue.
Consistent demos -- the same seed data appears every time.

When not set, Faker uses its default random seed, producing different data on each run.

Complete Example

import { Module } from "@nestjs/common";
import { ConfigModule, ConfigService } from "@nestjs/config";
import { TypeOrmModule } from "@nestjs/typeorm";
import { EventEmitterModule } from "@nestjs/event-emitter";
import { FactoryModule } from "@nestbolt/factory";
import { UserFactory } from "./factories/user.factory";
import { PostFactory } from "./factories/post.factory";
import { DatabaseSeeder } from "./seeders/database.seeder";

@Module({
  imports: [
    ConfigModule.forRoot(),
    EventEmitterModule.forRoot(),
    TypeOrmModule.forRoot({
      type: "postgres",
      host: "localhost",
      port: 5432,
      database: "myapp",
      synchronize: false,
    }),
    FactoryModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        factories: [UserFactory, PostFactory],
        seeders: [DatabaseSeeder],
        seed: config.get<number>("FAKER_SEED"),
      }),
    }),
  ],
})
export class AppModule {}

On this page