No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Prep谩rate para tu pr贸ximo empleo comprando hoy a precio especial

Antes: $249

Currency
$209
Suscr铆bete

Termina en:

7 D铆as
19 Hrs
28 Min
41 Seg

Tipado en config

11/17
Recursos

A medida que tu aplicaci贸n acumule m谩s y m谩s variables de entorno, puede volverse inmanejable y es propenso a tener errores el no recordar sus nombres o escribirlos mal. A continuaci贸n ver谩s como tipar variables.

C贸mo hacer el tipado de variables de entorno

Seguriza tu lista de variables de entorno de manera que evites errores que son dif铆ciles de visualizar. Veamos c贸mo puedes tipar tus variables.

1. Archivo de tipado de variables

Crea un archivo al que denominaremos config.ts que contendr谩 el tipado de tu aplicaci贸n con ayuda de la dependencia @nestjs/config.

// src/config.ts
import { registerAs } from "@nestjs/config";

export default registerAs('config', () => {
  return {
    database: {
      name: process.env.DATABASE_NAME,
      port: process.env.DATABASE_PORT,
    },
    apiKey: process.env.API_KEY,
  }
})

Importa registerAs desde @nestjs/config que servir谩 para crear el tipado de datos. Crea un objeto con la estructura de datos que necesita tu aplicaci贸n. Este objeto contiene los valores de las variables de entorno tomados con el objeto global de NodeJS, process.

2. Importaci贸n del tipado de datos

Importa el nuevo archivo de configuraci贸n en el m贸dulo de tu proyecto de la siguiente manera para que este sea reconocido.

import { ConfigModule } from '@nestjs/config';
import config from './config';

@Global()
@Module({
  imports: [
    HttpModule,
    ConfigModule.forRoot({
      envFilePath: '.env',
      load: [config],
      isGlobal: true
    }),
  ],
})
export class AppModule {}

3. Tipado de variables de entorno

Es momento de utilizar este objeto que genera una interfaz entre nuestra aplicaci贸n y las variables de entorno para no confundir el nombre de cada variable.

import { Controller, Inject } from '@nestjs/common';
import { ConfigType } from '@nestjs/config';
import config from './config';

@Controller()
export class AppController {

  constructor(
    @Inject(config.KEY) private configService: ConfigType<typeof config>
  ) {}
  
  getEnvs(): string {
    const apiKey = this.configService.apiKey;
    const name = this.configService.database.name;
    return `Envs: ${apiKey} ${name}`;
  }
}

Observa la configuraci贸n necesaria para inyectar y tipar tus variables de entorno. Ahora ya no tendr谩s que preocuparte por posibles errores al invocar a una de estas variables y evitar dolores de cabeza debugueando estos errores.

Cuadro de c贸digo para tipado en config

// .env
DATABASE_NAME=my_db_prod
API_KEY=999
DATABASE_PORT=8091 // 馃憟
// .stag.env
DATABASE_NAME=my_db_stag
API_KEY=333
DATABASE_PORT=8091 // 馃憟
// .prod.env
DATABASE_NAME=my_db_prod
API_KEY=999
DATABASE_PORT=8091 // 馃憟
// src/config.ts // 馃憟 new file
import { registerAs } from '@nestjs/config';

export default registerAs('config', () => { // 馃憟 export default
  return { 
    database: {
      name: process.env.DATABASE_NAME,
      port: process.env.DATABASE_PORT,
    },
    apiKey: process.env.API_KEY,
  };
});
// src/app.module.ts
import config from './config'; // 馃憟

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: enviroments[process.env.NODE_ENV] || '.env',
      load: [config], // 馃憟
      isGlobal: true,
    }),
    ...
  ],
  ...
})
export class AppModule {}
// src/app.service.ts
import { ConfigType } from '@nestjs/config'; // 馃憟 Import ConfigType 
import config from './config'; // 馃憟 config file

@Injectable()
export class AppService {
  constructor(
    @Inject('TASKS') private tasks: any[],
    @Inject(config.KEY) private configService: ConfigType<typeof config>, // 馃憟
  ) {}
  getHello(): string {
    const apiKey = this.configService.apiKey; // 馃憟
    const name = this.configService.database.name; // 馃憟
    return `Hello World! ${apiKey} ${name}`;
  }
}

Contribuci贸n creada por: Kevin Fiorentino.

Aportes 10

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

Apuntes

Tipar nuestro archivo de configuraci贸n le dar谩 el poder a typescript de ayudarnos a evitar errores triviales como escribir mal el nombre de una variable o no definir una variable en los archivos .env

Tipando el archivo de configuraci贸n

Para tipar el archivo de configuraci贸n debemos hacerlo con ayuda de la funcion registerAs incluida en el paquete de '@nestjs/config'

// src/config.ts // 馃憟 new file
import { registerAs } from '@nestjs/config';

export default registerAs('config', () => { // 馃憟 export default
  return { 
    database: {
      name: process.env.DATABASE_NAME,
      port: process.env.DATABASE_PORT,
    },
    apiKey: process.env.API_KEY,
  };
});

Esto lo venia haciendo con la dependencia dotenv en nodejs puro y duro jaja

Los apuntes de Angel son buenisimos!
Le agrego lo siguiente

Una vez terminado el config.ts hay que importarlo en el app.module.ts usando load:

import config from './config'; //importarlo

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: environments[process.env.NODE_ENV] || '.env',
      load: [config],
      isGlobal: true,
    }),
	...
     ],
})

Cambiamos el ConfigService por ConfigType en app.service.ts e importamos config. Luego lo inyectamos en el contructor.

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

@Injectable()
export class AppService {
  constructor(
    //@Inject('API_KEY') private apiKey: string,
    @Inject('TASKS') private tasks: any[],
    @Inject(config.KEY) private configService: ConfigType<typeof config>,
  ) {}
  getHello(): any {
    const apiKey = this.configService.apiKey;
    const dbName = this.configService.database.name;
    const dbPort = this.configService.database.port;
    return `api: ${apiKey} db: ${dbName} db_port: ${dbPort}`;
    //return this.tasks;
  }
}

Con enums se tambien se puede hacer

export enum config {
  apiKey = 'API_KEY',
  dbName = 'DATABASE_NAME',
}

Y se usa importandolo

import { config } from './config';

const apiKey = this.configService.get(config.apiKey);
Como observaci贸n leyendo la documentaci贸n, se puede inferir los tipos (types) usando una propiedad de **ConfigService, t**iene dos gen茅ricos opcionales (argumentos de tipo). El primero de ellos ayuda a prevenir el acceso a una propiedad de configuraci贸n que no existe. `const apiKey = this.config.get<string>('API_KEY', { infer: true });`

Configuraci贸n variables de entorno registerAs

Soluci贸n de bug

Ctrl + a para seleccionar todo el c贸digo

justo lo que necesitaba, muchas gracias

馃憦

Para este caso prefiero usar enums para evitar los magic strings, me parece mucho m谩s simple y r谩pido de configurar

export const FACTORY = {
  TASKS: 'TASKS',
} as const;

export const ENV_STATUS = {
  PROD: 'prod',
} as const;

export const ENV = {
  API_KEY: 'API_KEY',
  DATABASE_NAME: 'DATABASE_NAME',
  DATABASE_PORT: 'DATABASE_PORT',
} as const;