¿Qué son los proveedores personalizados y los tokens de inyección?

Question

Accepted Answer

Más allá de simples clases `@Injectable()`, NestJS soporta **proveedores personalizados** — formas flexibles de definir qué se inyecta — usando **tokens de inyección**. Esto te permite inyectar valores, configurar cómo se crean las instancias, intercambiar implementaciones e inyectar dependencias que no son clases.

## Los cuatro tipos de proveedores personalizados

```ts
@Module({
  providers: [
    // 1. useClass — standard (or swap the implementation behind a token)
    { provide: PaymentService, useClass: StripePaymentService },

// 2. useValue — inject a constant/object/mock (great for config and testing)
    { provide: "CONFIG", useValue: { apiKey: "abc", timeout: 5000 } },

// 3. useFactory — compute the provider dynamically (can use other deps)
    {
      provide: "DATABASE_CONNECTION",
      useFactory: async (config: ConfigService) => {
        return await createConnection(config.get("DB_URL"));   // async setup
      },
      inject: [ConfigService],        // dependencies for the factory
    },

// 4. useExisting — create an alias for an existing provider
    { provide: "ALIAS", useExisting: PaymentService },
  ],
})
export class AppModule {}
```

## Tokens de inyección — para dependencias que no son clases

```ts
// classes can be tokens directly (by type). For values/interfaces, use a string/Symbol token:
@Injectable()
export class PaymentProcessor {
  constructor(@Inject("CONFIG") private config: AppConfig) {}   // inject by token
}
```

Ya que no puedes inyectar una interfaz o un valor plano por tipo (no existen en tiempo de ejecución), usas un **token** (una cadena o `Symbol`) con `@Inject(token)` para inyectarlo. Así es cómo inyectas objetos de configuración, clientes de terceros, o dependencias tipadas con interfaz.

## useFactory — el más poderoso (setup dinámico y asincrónico)

```ts
// create a provider whose value depends on runtime config / async initialization
{
  provide: "REDIS_CLIENT",
  useFactory: (config: ConfigService) => new Redis(config.get("REDIS_URL")),
  inject: [ConfigService],
}
```

`useFactory` ejecuta una función (con dependencias inyectadas) para producir el proveedor — esencial para conexiones, clientes, o cualquier cosa que necesite configuración en tiempo de ejecución o setup asincrónico.

## Intercambiar implementaciones (useClass) — flexibilidad y testing

```ts
// inject a different implementation based on environment
{
  provide: PaymentService,
  useClass: process.env.NODE_ENV === "test" ? MockPaymentService : StripePaymentService,
}
```

Ya que los consumidores dependen del token (`PaymentService`), puedes intercambiar la clase concreta — un servicio real de Stripe en producción, un mock en tests — sin cambiar ningún código que consume.

## Por qué es importante

Los proveedores personalizados y los tokens de inyección extienden la inyección de dependencias de NestJS más allá de simples clases, dándote la flexibilidad necesaria para aplicaciones del mundo real.

Entenderlos es importante para varios escenarios comunes: **inyectar valores que no son clases** (objetos de configuración, constantes) vía `useValue` y tokens de cadena/Symbol (ya que no puedes inyectar interfaces o valores planos por tipo); **creación dinámica/asincrónica de proveedores** vía `useFactory` (la forma más poderosa — crear conexiones a bases de datos, clientes Redis, o instancias de SDK de terceros configuradas desde valores en tiempo de ejecución, con sus propias dependencias inyectadas); e **intercambiar implementaciones** vía `useClass` detrás de un token (habilitando implementaciones basadas en entorno y, crucialmente, **mocking fácil en tests** — proporcionar una clase mock para un token sin tocar los consumidores).

Esta flexibilidad es lo que hace que la DI de NestJS sea poderosa para arquitectura en producción y excelente testabilidad.

Conocer los cuatro tipos de proveedores (`useClass`, `useValue`, `useFactory`, `useExisting`), cómo funcionan los tokens de inyección para dependencias que no son clases, y cuándo usar cada uno es un paso importante más allá de la DI básica — es cómo conectas bases de datos, servicios externos, configuración, y dependencias intercambiables/mockables de la forma idiomática de NestJS, convirtiéndolo en un tema arquitectónicamente significativo y frecuentemente necesario en aplicaciones reales.