Providers asíncronos

Qué es un provider asíncrono

Los providers asíncronos en NestJS son servicios que requieren operaciones asíncronas durante su inicialización antes de estar disponibles para la inyección de dependencias. A diferencia de los providers síncronos tradicionales, estos necesitan completar tareas como conexiones a bases de datos, llamadas a APIs externas o lectura de archivos de configuración antes de que la aplicación pueda utilizarlos.

Casos de uso comunes

Los providers asíncronos resultan especialmente útiles en escenarios donde necesitas:

• Establecer conexiones a bases de datos que requieren autenticación
• Cargar configuraciones desde servicios externos o archivos remotos
• Inicializar clientes de APIs de terceros con credenciales dinámicas
• Configurar servicios que dependen de recursos externos

Implementación básica

Para crear un provider asíncrono, utilizas la función useFactory junto con la propiedad inject para especificar las dependencias necesarias:

import { Module } from '@nestjs/common';

@Module({
  providers: [
    {
      provide: 'DATABASE_CONNECTION',
      useFactory: async () => {
        // Simulación de conexión asíncrona
        const connection = await createDatabaseConnection({
          host: 'localhost',
          port: 5432,
          database: 'myapp'
        });
        return connection;
      },
    },
  ],
  exports: ['DATABASE_CONNECTION'],
})
export class DatabaseModule {}

Inyección de dependencias en providers asíncronos

Cuando tu provider asíncrono necesita otras dependencias, puedes inyectarlas usando la propiedad inject:

@Module({
  providers: [
    ConfigService,
    {
      provide: 'API_CLIENT',
      useFactory: async (configService: ConfigService) => {
        const apiKey = await configService.getApiKey();
        const baseUrl = configService.get('API_BASE_URL');
        
        return new ApiClient({
          apiKey,
          baseUrl,
          timeout: 5000
        });
      },
      inject: [ConfigService],
    },
  ],
})
export class ApiModule {}

Manejo de errores en la inicialización

Es fundamental implementar un manejo adecuado de errores en los providers asíncronos, ya que los fallos durante la inicialización pueden impedir que la aplicación arranque correctamente:

{
  provide: 'REDIS_CLIENT',
  useFactory: async (configService: ConfigService) => {
    try {
      const redisConfig = {
        host: configService.get('REDIS_HOST'),
        port: configService.get('REDIS_PORT'),
        password: configService.get('REDIS_PASSWORD')
      };
      
      const client = new Redis(redisConfig);
      await client.ping(); // Verificar conexión
      
      return client;
    } catch (error) {
      console.error('Error conectando a Redis:', error);
      throw new Error('No se pudo establecer conexión con Redis');
    }
  },
  inject: [ConfigService],
}

Uso en servicios

Una vez configurado el provider asíncrono, puedes inyectarlo en tus servicios utilizando el decorador @Inject() con el token correspondiente:

import { Injectable, Inject } from '@nestjs/common';

@Injectable()
export class UserService {
  constructor(
    @Inject('DATABASE_CONNECTION') 
    private readonly dbConnection: any,
    @Inject('API_CLIENT') 
    private readonly apiClient: any
  ) {}

  async findUser(id: string) {
    // Usar la conexión inicializada
    return await this.dbConnection.query('SELECT * FROM users WHERE id = ?', [id]);
  }

  async syncUserData(userId: string) {
    // Usar el cliente API inicializado
    return await this.apiClient.get(`/users/${userId}`);
  }
}

La inicialización asíncrona garantiza que todos los recursos externos estén disponibles y correctamente configurados antes de que tu aplicación comience a procesar peticiones, proporcionando una base sólida para el funcionamiento de tus servicios.