Validación de Variables de Entorno con Joi en Node.js

Clase 12 de 17 • Curso de NestJS: Programación Modular, Documentación con Swagger y Deploy

Contenido del curso

Módulos de NestJS

Configuración de entornos

Documentación

Deploy

Próximos pasos

17
Inyección de Dependencias en APIs con Heroku
01:04 min

Tomar examen

Resumen

Las variables de entorno son sensibles, pueden ser requeridas o no, pueden ser un string o un number. Validemos tus variables de entorno para evitar errores u omisiones de las mismas.

Validando variables de entorno

Instala la dependencia Joi con el comando npm instal joi --save. La misma nos dará las herramientas para realizar validaciones de nuestras variables de entorno.

Importa Joi en el módulo de tu aplicación y a través de la propiedad validationSchema del objeto que recibe el ConfigModule crea el tipado y las validaciones de tus variables de entorno.

import { ConfigModule } from '@nestjs/config';
import * as Joi from 'joi';

import config from './config';

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: '.env',
      load: [config],
      isGlobal: true,
      validationSchema: Joi.object({
        API_KEY: Joi.string().required(),
        DATABASE_NAME: Joi.string().required(),
        DATABASE_PORT: Joi.number().required(),
      })
    }),
  ],
  ],
})
export class AppModule {}

Lo que hace Joi es asegurar que, en el archivo .env, existan las variables de entorno indicadas dependiendo si son obligatorias o no, además de validar el tipo para no ingresar un string donde debería ir un number.

En equipos de trabajo profesional, quienes suelen desplegar las aplicaciones en los entornos es el equipo DevOpsy ellos no necesariamente saben qué variables de entorno necesita tu aplicación y de qué tipo son. Gracias a esta configuración, tu app emitirá mensajes de error claros por consola cuando alguna variable no sea correcta.

Curso Profesional de DevOps

Cuadro de código para variables de entorno

npm install --save joi

// src/app.module.ts

import * as Joi from 'joi';  // 👈

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: enviroments[process.env.NODE_ENV] || '.env',
      load: [config],
      isGlobal: true,
      validationSchema: Joi.object({ // 👈
        API_KEY: Joi.number().required(),
        DATABASE_NAME: Joi.string().required(),
        DATABASE_PORT: Joi.number().required(),
      }),
    }),
    ...
  ],
  ...
})
export class AppModule {}

Contribución creada por: Kevin Fiorentino.

Jorge Carrion

student•

Me tocó hacer lo mismo pero con class-validator, dejo mi aporte por si a alguien le sirve:

.env.validation.ts

import { IsEnum, IsNumber, IsString, validateSync } from 'class-validator';
import { plainToClass } from 'class-transformer';
import { Environment } from '../src/common/models/environment.model';
class EnvironmentVariables {
  // Environment
  @IsString()
  @IsEnum(Environment)
  ENV: Environment;

  // Server config
  @IsNumber()
  PORT: number;

  @IsString()
  END_POINT: string;
}

export function validate(config: Record<string, unknown>) {
  const validatedConfig = plainToClass(EnvironmentVariables, config, {
    enableImplicitConversion: true,
  });
  const errors = validateSync(validatedConfig, {
    skipMissingProperties: false,
  });

  if (errors.length > 0) {
    throw new Error(`ENV validation error` + errors.toString());
  }
  return validatedConfig;
}
}

configuration.ts:

import { registerAs } from '@nestjs/config';

export default registerAs('config', () => {
  return {
    environment: process.env.ENV,
    server: {
      port: parseInt(process.env.PORT, 10) || 3000,
      endpoint: process.env.END_POINT,
    },
  };
});

app.module.ts

import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';

import config from '../config/configuration';
import { validate } from 'config/env.validation';

import { LoggerMiddleware } from './common/middleware/appLogger.middleware';

@Module({
  imports: [
    ConfigModule.forRoot({
      load: [config],
      validate,
      isGlobal: true,
    }),
  ],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer): void {
    consumer.apply(LoggerMiddleware).forRoutes('*');
  }
}

Erick Saravia

student•

Igual en mi caso prefiero class-validator me parece que queda más limpio el código, me imagino que en este caso mostraron joi para mostrar ambas opciones para validar, ya que ambas son aceptadas

Sebastián Hoyos López

student•

Buenos días, quisiera que me ayudaras con el archivo "LoggerMiddleware", cuál sería su configuración?

Fernando Cordero

Jecsham Castillo

Vsqz Gabriel

Ricardo Lopez

Andrés Felipe Martínez Salazar

Gustavo Restrepo

Jairo Rivera Cueva

Walter Lensinas

Miguel Angel Reyes Moreno

Oscar David Arcos Rodriguez

Carlos Vallejo

José Mauricio Lemus Rodezno

Cristian Andrés Loaiza Arias

Hugo Roca

Andrew Alfaro Carrillo

Ayriel Noriega

Gonzalo Gutiérrez Castillo

Nicolás Giménez

Erizon Encina

Anderson Quezada

Validación de Variables de Entorno con Joi en Node.js

Módulos de NestJS

Programación Modular y Deployment en Nest GS

Encapsulación de Lógica en Módulos con NestJS

Programación Modular en NestJS: Controladores y Entidades

Interacción entre Módulos en NestJS: Servicios y Controladores

Inyección de Dependencias en Arquitectura de Software

Tipos de Providers en NestJS: Use Class y Use Value

useFactory

Uso de Módulos Globales en NestJS para Inyecciones Compartidas

Configuración de entornos

Configuración y uso de variables de entorno en NestJS

Configuración de Ambientes con Archivos .env en Node.js

Tipado seguro en TypeScript para configuración de aplicaciones