Что входит в модуль в NestJS?

Модуль в NestJS: что входит

Модуль — логическая единица приложения, содержащая controller(ы), service(ы) и их dependencies. Это не просто папка, а封装된 компонент с чётким API.

Основная структура

@Module({
  imports: [],      // Что этот модуль использует
  controllers: [],  // HTTP endpoints
  providers: [],    // Services, repositories, factories
  exports: [],      // Что предоставляет другим модулям
})
export class UsersModule {}

1. PROVIDERS — создание и инъекция

Providers — это классы/значения, которые может инстанцировать и инжектировать Nest:

// Service (бизнес-логика)
@Injectable()
export class UsersService {
  async findAll() { }
  async findOne(id: string) { }
}

// Repository (работа с БД)
@Injectable()
export class UsersRepository {
  constructor(private db: Repository<User>) {}
}

@Module({
  providers: [
    UsersService,
    UsersRepository,
    // или явно:
    {
      provide: 'CONFIG',
      useValue: { port: 3000 },
    },
    {
      provide: 'DB_CONNECTION',
      useFactory: () => new Database(),
    },
  ],
})

2. CONTROLLERS — HTTP endpoints

Controllers обрабатывают HTTP запросы:

@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}
  
  @Get()
  async findAll() {
    return this.usersService.findAll();
  }
  
  @Post()
  async create(@Body() dto: CreateUserDto) {
    return this.usersService.create(dto);
  }
}

@Module({
  providers: [UsersService],
  controllers: [UsersController],  // Можно несколько
})

3. IMPORTS — использование других модулей

Импорты подключают другие модули и их функциональность:

@Module({
  imports: [
    TypeOrmModule.forFeature([User]),  // Встроенный модуль NestJS
    ConfigModule,                       // Свой модуль
    AuthModule,
  ],
  providers: [UsersService],
  controllers: [UsersController],
})
export class UsersModule {}

4. EXPORTS — публичный API

Exports определяет, что другие модули могут использовать:

// users.module.ts
@Module({
  providers: [UsersService, PasswordHasher],
  exports: [UsersService],  // Только UsersService доступен снаружи
})
export class UsersModule {}

// orders.module.ts
@Module({
  imports: [UsersModule],  // Импортируем для доступа к UsersService
  providers: [OrdersService],
})
export class OrdersModule {}

// orders.service.ts
@Injectable()
export class OrdersService {
  constructor(private usersService: UsersService) {}  // Доступен!
}

Полный пример

// users.service.ts
@Injectable()
export class UsersService {
  constructor(private db: Repository<User>) {}
  
  async create(email: string, name: string) {
    return this.db.save({ email, name });
  }
  
  async findAll() {
    return this.db.find();
  }
}

// users.controller.ts
@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}
  
  @Post()
  async create(@Body() dto: CreateUserDto) {
    return this.usersService.create(dto.email, dto.name);
  }
  
  @Get()
  async findAll() {
    return this.usersService.findAll();
  }
}

// users.module.ts
@Module({
  imports: [
    TypeOrmModule.forFeature([User]),
  ],
  providers: [UsersService],
  controllers: [UsersController],
  exports: [UsersService],  // Другие модули могут использовать
})
export class UsersModule {}

// app.module.ts
@Module({
  imports: [
    TypeOrmModule.forRoot({ /* ... */ }),
    UsersModule,
    OrdersModule,
    AuthModule,
  ],
})
export class AppModule {}

Жизненный цикл модуля

@Module({
  providers: [UsersService],
})
export class UsersModule implements OnModuleInit, OnModuleDestroy {
  onModuleInit() {
    console.log('UsersModule initialized');
    // Запустить инициализацию
  }
  
  onModuleDestroy() {
    console.log('UsersModule destroyed');
    // Закрыть connections
  }
}

Global модули

Если модуль нужен везде (например ConfigModule):

@Global()
@Module({
  providers: [ConfigService],
  exports: [ConfigService],
})
export class ConfigModule {}

// Теперь ConfigService доступен везде БЕЗ импорта ConfigModule

Dynamic modules (forRoot pattern)

@Module({})
export class DatabaseModule {
  static forRoot(options: DatabaseOptions): DynamicModule {
    return {
      module: DatabaseModule,
      providers: [
        {
          provide: 'DB_OPTIONS',
          useValue: options,
        },
        DatabaseService,
      ],
      exports: [DatabaseService],
    };
  }
}

// app.module.ts
@Module({
  imports: [
    DatabaseModule.forRoot({
      host: 'localhost',
      port: 5432,
    }),
  ],
})
export class AppModule {}

Итоговая структура модуля

Что входит:

1. PROVIDERS — сервисы, репозитории, custom providers
2. CONTROLLERS — HTTP endpoints
3. IMPORTS — зависимые модули
4. EXPORTS — публичный API для других модулей

Идеология:

• Каждый модуль отвечает за одну область (users, orders, auth)
• Module = Container + HTTP Endpoints
• Модули инъектируют зависимости через constructor
• Exports контролируют видимость (инкапсуляция)

Архитектурный паттерн:

AppModule (root)
  ├── UsersModule
  │   ├── UsersController
  │   ├── UsersService
  │   └── UsersRepository
  ├── AuthModule
  │   └── AuthService
  └── OrdersModule
      ├── OrdersController
      └── OrdersService

Модули — это способ организовать код в логические, переиспользуемые и тестируемые единицы.