Configuration namespaces in NestJS

Introduction

Configuration namespaces help organize settings into groups. This makes managing app settings easier and clearer.

When your app has many settings that belong to different parts, like database and server.

When you want to avoid mixing unrelated configuration values.

When you want to load or override settings for specific parts without affecting others.

When you want to keep your configuration clean and easy to read.

When you want to share configuration logic across modules in a structured way.

Syntax

NestJS

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

export const databaseConfig = registerAs('database', () => ({
  host: process.env.DB_HOST || 'localhost',
  port: parseInt(process.env.DB_PORT || '5432', 10),
}));

registerAs creates a named configuration namespace.

The first argument is the namespace name as a string.

Examples

This creates a server namespace with port and debug settings.

NestJS

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

export const serverConfig = registerAs('server', () => ({
  port: parseInt(process.env.SERVER_PORT || '3000', 10),
  debug: process.env.DEBUG === 'true',
}));

This creates an auth namespace for authentication settings.

NestJS

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

export const authConfig = registerAs('auth', () => ({
  jwtSecret: process.env.JWT_SECRET || 'defaultsecret',
  expiresIn: process.env.JWT_EXPIRES || '3600s',
}));

Sample Program

This example shows how to create a database namespace, load it with ConfigModule, and use a factory provider to read and log the settings using ConfigService with the namespace prefix.

NestJS

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { registerAs } from '@nestjs/config';

const databaseConfig = registerAs('database', () => ({
  host: process.env.DB_HOST || 'localhost',
  port: parseInt(process.env.DB_PORT || '5432', 10),
}));

@Module({
  imports: [
    ConfigModule.forRoot({
      load: [databaseConfig],
    }),
  ],
  providers: [
    {
      provide: 'DB_CONFIG_LOGGER',
      useFactory: (configService: ConfigService) => {
        const dbHost = configService.get('database.host');
        const dbPort = configService.get('database.port');
        console.log(`Database Host: ${dbHost}`);
        console.log(`Database Port: ${dbPort}`);
        return null;
      },
      inject: [ConfigService],
    },
  ],
})
export class AppModule {}

Important Notes

Namespaces help avoid name clashes between different config parts.

You access values using dot notation like namespace.key.

Use environment variables inside namespaces for flexible settings.

Summary

Configuration namespaces group related settings together.

Use registerAs to create namespaces in NestJS.

Access namespaced settings with dot notation via ConfigService.

Practice

1. What is the main purpose of using registerAs in NestJS configuration?

easy

A. To create a database connection

B. To register a global middleware in the application

C. To define a new module in NestJS

D. To create a named namespace grouping related configuration settings

Solution

1. Step 1: Understand the role of registerAs

   registerAs is used to define a configuration namespace, grouping related settings under one name.

2. Step 2: Differentiate from other NestJS features

   It is not used for middleware, modules, or database connections, which are handled differently.

3. Final Answer:

   To create a named namespace grouping related configuration settings -> Option D

4. Quick Check:

   registerAs creates config namespaces = A [OK]

Hint: Remember: registerAs groups config keys under one name [OK]

Common Mistakes:

• Confusing registerAs with module registration
• Thinking registerAs sets up middleware
• Assuming registerAs creates database connections

2. Which of the following is the correct syntax to create a configuration namespace called 'database' using registerAs?

easy

A. export const database = registerAs('database', () => ({ host: 'localhost' }));

B. registerAs('database', { host: 'localhost' });

C. export default registerAs('database', () => ({ host: 'localhost' }));

D. registerAs('database', () => { host: 'localhost' });

Solution

1. Step 1: Check correct export and function syntax

   The correct pattern is to export a constant assigned to registerAs with a name and a function returning an object.

2. Step 2: Identify syntax errors in options

   export default registerAs('database', () => ({ host: 'localhost' })); uses default export but misses const assignment. registerAs('database', { host: 'localhost' }); passes object directly, not a function. registerAs('database', () => { host: 'localhost' }); misses returning an object (no parentheses).

3. Final Answer:

   export const database = registerAs('database', () => ({ host: 'localhost' })); -> Option A

4. Quick Check:

   Correct syntax = A [OK]

Hint: Use export const with registerAs and a function returning config [OK]

Common Mistakes:

• Passing object directly instead of function
• Missing export const declaration
• Not returning an object from the function

3. Given the following configuration namespace registered as 'app':

export const appConfig = registerAs('app', () => ({ port: 3000, env: 'dev' }));

What will configService.get('app.port') return?

medium

A. 3000

B. 'app.port'

C. undefined

D. An error is thrown

Solution

1. Step 1: Understand dot notation access in ConfigService

   Using configService.get('app.port') accesses the 'port' key inside the 'app' namespace.

2. Step 2: Check the registered config values

   The 'app' namespace returns an object with port: 3000, so the call returns 3000.

3. Final Answer:

   3000 -> Option A

4. Quick Check:

   configService.get('namespace.key') returns value = B [OK]

Hint: Use dot notation to get nested config values [OK]

Common Mistakes:

• Expecting the string 'app.port' as output
• Assuming undefined if namespace not accessed properly
• Thinking it throws an error for valid keys

4. Consider this code snippet:

export const apiConfig = registerAs('api', () => ({ url: 'https://api.example.com' }));

// Later in service
const url = configService.get('api.url');

What is the likely cause if url is undefined?

medium

A. The configService instance is not injected properly

B. The namespace 'api' was not imported or registered in ConfigModule

C. Dot notation is not supported in configService.get()

D. The key 'url' does not exist in the 'api' namespace

Solution

1. Step 1: Check registration of namespace

   If the 'api' namespace is not imported or registered in the ConfigModule, its keys won't be available.

2. Step 2: Verify key existence and usage

   The key 'url' exists in the namespace, and dot notation is supported, so these are not issues.

3. Step 3: Consider injection issues

   While injection problems can cause errors, they usually throw exceptions, not silently return undefined.

4. Final Answer:

   The namespace 'api' was not imported or registered in ConfigModule -> Option B

5. Quick Check:

   Missing namespace registration = D [OK]

Hint: Always import and register namespaces in ConfigModule [OK]

Common Mistakes:

• Assuming dot notation is unsupported
• Thinking missing key causes error instead of undefined
• Ignoring namespace registration step

5. You have two configuration namespaces registered:

export const dbConfig = registerAs('database', () => ({ host: 'localhost', port: 5432 }));
export const authConfig = registerAs('auth', () => ({ jwtSecret: 'secret' }));

How can you access the JWT secret inside a service using ConfigService and ensure type safety?

hard

A. const secret = configService.get<number>('auth.jwtSecret');

B. const secret = configService.get('jwtSecret');

C. const secret = configService.get<string>('auth.jwtSecret');

D. const secret = configService.get('database.jwtSecret');

Solution

1. Step 1: Use dot notation with namespace and key

   To access the JWT secret, use 'auth.jwtSecret' to specify the namespace and key.

2. Step 2: Apply type safety with generic parameter

   Pass <string> to get to ensure the returned value is typed as string.

3. Step 3: Eliminate incorrect options

   const secret = configService.get('jwtSecret'); misses namespace, A uses wrong type, D uses wrong namespace.

4. Final Answer:

   const secret = configService.get<string>('auth.jwtSecret'); -> Option C

5. Quick Check:

   Use namespace.key with type param = C [OK]

Hint: Use configService.get<Type>('namespace.key') for typed access [OK]

Common Mistakes:

• Omitting namespace in key string
• Using wrong type parameter
• Accessing key from wrong namespace