0Pricing
NestJS Enterprise Backend APIs · Lesson

Namespaced Config with registerAs

Group related settings into typed config namespaces and inject them with ConfigService.get.

Namespaced Config with registerAs is a free NestJS Enterprise Backend APIs lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the NestJS Enterprise Backend APIs learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

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.

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.

Frequently asked questions

Is the “Namespaced Config with registerAs” lesson free?

Yes — the full text of “Namespaced Config with registerAs” is free to read here on the web, and the NestJS Enterprise Backend APIs course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the NestJS Enterprise Backend APIs course, upgrade to CoddyKit PRO.

What will I learn in “Namespaced Config with registerAs”?

Group related settings into typed config namespaces and inject them with ConfigService.get. You practise NestJS Enterprise Backend APIs with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start NestJS Enterprise Backend APIs?

No prior experience is required. NestJS Enterprise Backend APIs on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Namespaced Config with registerAs” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this NestJS Enterprise Backend APIs lesson?

Yes. Every NestJS Enterprise Backend APIs lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Schema-Validated Env with Joi and forRoot
  2. Namespaced Config with registerAs
  3. Loading Secrets from HashiCorp Vault and AWS SSM
  4. Per-Environment Config and Safe Defaults
← Back to NestJS Enterprise Backend APIs