En NestJS, un provider es cualquier clase que puede ser inyectada como una dependencia, y un service es el tipo más común — una clase que contiene lógica de negocio. Marcar una clase con @Injectable() la convierte en un provider que el sistema DI de NestJS puede crear e inyectar.
import { Injectable } from "@nestjs/common";
@Injectable() // marks the class as a provider (injectable)
export class UsersService {
private users = [];
findAll() { return this.users; } // business logic
findOne(id: string) { return this.users.find(u => u.id === id); }
create(data) { this.users.push(data); return data; }
}
El decorador @Injectable() le dice a NestJS que esta clase participa en inyección de dependencias — puede ser inyectada en controladores u otros providers.
@Controller("users")
export class UsersController {
// NestJS sees this parameter and INJECTS a UsersService instance automatically
constructor(private usersService: UsersService) {}
@Get()
findAll() {
return this.usersService.findAll(); // use the injected service
}
}
Declaras la dependencia como un parámetro del constructor; NestJS crea y suministra la instancia — nunca escribes new UsersService().
@Module({
controllers: [UsersController],
providers: [UsersService], // register the provider so DI can resolve it
exports: [UsersService], // make it available to OTHER modules that import this one
})
export class UsersModule {}
Los providers deben estar registrados en el array providers de un módulo para que DI conozca su existencia, y exports los comparte con otros módulos.
By default, NestJS creates ONE shared instance of each provider (singleton scope)
for the whole application → efficient, shared state.
(Other scopes exist: REQUEST-scoped, TRANSIENT — but singleton is the default.)
Controller → handles HTTP (routing, request/response)
Service → handles business logic (rules, data access, computations)
→ Separation makes logic REUSABLE (multiple controllers can use one service),
TESTABLE (test the service in isolation), and ORGANIZED.
Los providers y services son fundamentales para la arquitectura de NestJS y su diseño impulsado por inyección de dependencias.
Los services contienen la lógica de negocio de la aplicación, separada de los controladores (que solo manejan aspectos HTTP) — esta separación de responsabilidades hace que la lógica sea reutilizable en todos los controladores, fácilmente comprobable de forma aislada y bien organizada.
Entender que @Injectable() marca una clase como un provider inyectable, que los providers se registran en módulos e inyectan mediante constructores (DI crea las instancias para ti), y que son singletons por defecto es conocimiento fundamental cotidiano de NestJS.
El patrón provider/service, combinado con controladores y módulos, es la columna vertebral de cada aplicación NestJS — dominarlo es esencial para construir backends bien estructurados y mantenibles, y es uno de los primeros conceptos a aprender en el framework.