NestJS Enterprise Backend APIs · Lección

Configuración con espacios de nombres mediante registerAs

Agrupe ajustes relacionados en espacios de nombres de configuración tipados e inyéctelos con ConfigService.get.

Lección 2 de 413 pasos

Configuración con espacios de nombres mediante registerAs es una lección gratuita de NestJS Enterprise Backend APIs en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de NestJS Enterprise Backend APIs, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de NestJS Enterprise Backend APIs incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

The Problem With Flat Config

As an API grows, dumping every setting into one giant ConfigService namespace becomes unmanageable. You end up with calls like config.get('DB_HOST'), config.get('REDIS_PORT'), and config.get('JWT_SECRET') scattered everywhere with no grouping and no type safety.

No structure — database, cache, and auth keys all live at the same flat level.
No types — get() returns unknown or a loosely typed value.
Hard to refactor — renaming a key means hunting raw strings across the codebase.

NestJS solves this with namespaced configuration via the registerAs helper from @nestjs/config.

Introducing registerAs

registerAs(token, factory) creates a configuration factory bound to a namespace token. The factory reads from process.env and returns a typed object grouping related settings together.

Each namespace becomes its own logical unit — database, jwt, redis — that you can register, inject, and test independently.

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

export default registerAs('database', () => ({
  host: process.env.DB_HOST ?? 'localhost',
  port: parseInt(process.env.DB_PORT ?? '5432', 10),
  username: process.env.DB_USER ?? 'postgres',
  password: process.env.DB_PASSWORD ?? '',
  name: process.env.DB_NAME ?? 'app',
}));

Registering the Namespace

You load namespaced factories through the load array of ConfigModule.forRoot. Each entry is a factory created by registerAs.

Mark the module isGlobal: true so the ConfigService is available everywhere without re-importing.

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import databaseConfig from './config/database.config';
import jwtConfig from './config/jwt.config';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      load: [databaseConfig, jwtConfig],
    }),
  ],
})
export class AppModule {}

Reading a Namespace With get()

Once registered, the whole namespace is available under its token. Calling configService.get('database') returns the entire grouped object.

You can also reach a single nested value with dotted-path access: configService.get('database.host').

import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class DbConnector {
  constructor(private readonly config: ConfigService) {}

  connect() {
    const host = this.config.get<string>('database.host');
    const port = this.config.get<number>('database.port');
    return `connecting to ${host}:${port}`;
  }
}

Typing the Namespace

To get real type safety, derive a type from the factory using ConfigType. This infers the exact shape returned by your registerAs factory — no manual interface to keep in sync.

ConfigType<typeof databaseConfig> gives you { host: string; port: number; ... }.
Autocomplete and compile-time checks now work on every field.

import { ConfigType } from '@nestjs/config';
import databaseConfig from './config/database.config';

// Inferred: { host: string; port: number; username: string; ... }
type DatabaseConfig = ConfigType<typeof databaseConfig>;

function describe(db: DatabaseConfig): string {
  return `${db.username}@${db.host}:${db.port}/${db.name}`;
}

Injecting the Namespace Directly

The most ergonomic pattern is to inject the namespace token directly instead of going through ConfigService.get everywhere. Use the @Inject(databaseConfig.KEY) decorator — registerAs attaches a KEY property to the factory for exactly this.

Now the field is fully typed and the dependency is explicit in the constructor.

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

@Injectable()
export class UserRepository {
  constructor(
    @Inject(databaseConfig.KEY)
    private readonly db: ConfigType<typeof databaseConfig>,
  ) {}

  dsn(): string {
    return `postgres://${this.db.host}:${this.db.port}/${this.db.name}`;
  }
}

Why Inject the Token Over ConfigService

Both approaches work, but injecting the namespace token has clear advantages at scale:

Type-safe — the injected object is fully typed; no get<T> casts that can silently drift.
Explicit dependencies — the constructor declares exactly which config it needs.
Smaller surface — a class touching only database config never sees JWT or Redis keys.
Easier tests — provide a plain object for databaseConfig.KEY instead of mocking ConfigService.

Multiple Namespaces Side by Side

Real enterprise apps have several namespaces. Each is its own file and factory, registered together in the load array. Keeping them separate means a JWT change never risks breaking database config.

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

export const jwtConfig = registerAs('jwt', () => ({
  secret: process.env.JWT_SECRET ?? 'dev-secret',
  accessTtl: process.env.JWT_ACCESS_TTL ?? '15m',
  refreshTtl: process.env.JWT_REFRESH_TTL ?? '7d',
}));

export const redisConfig = registerAs('redis', () => ({
  host: process.env.REDIS_HOST ?? 'localhost',
  port: parseInt(process.env.REDIS_PORT ?? '6379', 10),
  ttl: parseInt(process.env.REDIS_TTL ?? '60', 10),
}));

Coercion Lives in the Factory

Environment variables are always strings. The namespace factory is the right place to coerce and default them once, so consumers always receive correct types.

This pure helper shows the coercion logic you would put inside a registerAs factory — it can run standalone.

function buildDbConfig(env: Record<string, string | undefined>) {
  return {
    host: env.DB_HOST ?? 'localhost',
    port: parseInt(env.DB_PORT ?? '5432', 10),
    ssl: env.DB_SSL === 'true',
    poolSize: parseInt(env.DB_POOL_SIZE ?? '10', 10),
  };
}

const cfg = buildDbConfig({ DB_PORT: '6543', DB_SSL: 'true' });
console.log(cfg.port, typeof cfg.port); // 6543 'number'
console.log(cfg.ssl, typeof cfg.ssl);   // true 'boolean'
console.log(cfg.host);                  // localhost

Using a Namespace in forRootAsync

Other modules can consume a namespace asynchronously. Inject the namespace token via inject and read the typed object in useFactory — for example, wiring TypeORM from your database namespace.

import { ConfigType } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import databaseConfig from './config/database.config';

TypeOrmModule.forRootAsync({
  inject: [databaseConfig.KEY],
  useFactory: (db: ConfigType<typeof databaseConfig>) => ({
    type: 'postgres',
    host: db.host,
    port: db.port,
    username: db.username,
    password: db.password,
    database: db.name,
  }),
});

Common Pitfalls

Watch out for these mistakes when working with namespaced config:

Forgetting to load the factory in load: [...] — the namespace will be undefined.
Mixing tokens and paths — get('database') returns the object; get('database.host') returns the leaf. Don't confuse them.
Re-coercing in consumers — coerce once in the factory; consumers should trust the types.
Using process.env directly in services instead of injecting the namespace, losing types and testability.

Quick Check

Test your understanding of namespaced config injection.

Responde en la lección interactiva

Recap

You learned how to group settings into typed config namespaces with registerAs:

registerAs(token, factory) groups related env vars into one named, typed object.
Register factories via ConfigModule.forRoot({ load: [...] }).
Read a namespace with config.get('database') or a leaf with config.get('database.host').
Prefer @Inject(config.KEY) with ConfigType<typeof config> for full type safety and explicit dependencies.
Do all coercion and defaults inside the factory so consumers trust the types.

This pattern keeps configuration structured, typed, and testable as your enterprise API scales.

Gratis para empezar

Aprende TypeScript con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 20
Lecciones: 76

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Configuración con espacios de nombres mediante registerAs» es gratis?

Sí — el texto completo de «Configuración con espacios de nombres mediante registerAs» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de NestJS Enterprise Backend APIs, actualiza a CoddyKit PRO. El curso de NestJS Enterprise Backend APIs incluye 4 lecciones en total.

¿Qué aprenderé en «Configuración con espacios de nombres mediante registerAs»?

Agrupe ajustes relacionados en espacios de nombres de configuración tipados e inyéctelos con ConfigService.get. Practicas NestJS Enterprise Backend APIs con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar NestJS Enterprise Backend APIs?

No se requiere experiencia previa. NestJS Enterprise Backend APIs en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Configuración con espacios de nombres mediante registerAs»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de NestJS Enterprise Backend APIs?

Sí. Cada lección de NestJS Enterprise Backend APIs incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Variables de entorno validadas por esquema con Joi y forRoot
Configuración con espacios de nombres mediante registerAs
Carga de secretos desde HashiCorp Vault y AWS SSM
Configuración por entorno y valores predeterminados seguros

← Volver a NestJS Enterprise Backend APIs