Custom configuration files in NestJS - Step-by-Step Execution

Concept Flow - Custom configuration files

Create config file

↓

Export config object

↓

Import config in module

↓

Use ConfigModule.forRoot({ load: [customConfig

↓

Inject ConfigService

↓

Access config values with get()

↓

Use config values in app

This flow shows how to create a custom config file, load it with ConfigModule, inject ConfigService, and access config values.

Execution Sample

NestJS

export default () => ({
  port: 3000,
  database: { host: 'localhost', port: 5432 },
});

Defines a custom configuration object with port and database settings.

Execution Table

Step	Action	Input/Code	Result/State
1	Create config file	export default () => ({ port: 3000, database: { host: 'localhost', port: 5432 } })	Config function ready to export
2	Import config in app module	import customConfig from './custom.config'	customConfig function available
3	Load config with ConfigModule	ConfigModule.forRoot({ load: [customConfig] })	ConfigModule loads customConfig into ConfigService
4	Inject ConfigService in service	constructor(private configService: ConfigService) {}	ConfigService instance ready
5	Access config value	this.configService.get('port')	Returns 3000
6	Access nested config	this.configService.get('database.host')	Returns 'localhost'
7	Use config value	app.listen(port)	App listens on port 3000
8	Exit	N/A	App running with custom config loaded

💡 App starts listening after loading custom configuration values

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	Final
customConfig	undefined	Function returning config object	Loaded into ConfigService	N/A	N/A
configService	undefined	undefined	Instance created	Has config values	Used to get config
port	undefined	undefined	undefined	3000	3000

Key Moments - 3 Insights

Why do we export a function instead of a plain object in the config file?

Exporting a function allows the config to be dynamic and evaluated when loaded, as shown in step 1 and 3 of the execution_table.

How do we access nested configuration values like database host?

Use dot notation in get(), e.g., get('database.host'), as shown in step 6 of the execution_table.

What happens if we forget to load the custom config in ConfigModule?

ConfigService won't have the custom values, so get() returns undefined or defaults, shown by the importance of step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what does this.configService.get('port') return at step 5?

A undefined

B 3000

C Error

D null

💡 Hint

Check step 5 in execution_table where get('port') returns 3000

At which step is the customConfig function loaded into ConfigService?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at step 3 in execution_table where ConfigModule.forRoot loads customConfig

If we change the port in customConfig to 4000, what changes in variable_tracker?

A port changes to 4000 after step 5

B customConfig becomes undefined

C configService is undefined

D No change in port value

💡 Hint

Variable 'port' value after step 5 reflects the configService.get('port') result

Concept Snapshot

Custom config files in NestJS:
- Export a function returning config object
- Load with ConfigModule.forRoot({ load: [customConfig] })
- Inject ConfigService to access values
- Use get('key') or get('nested.key')
- Enables dynamic, organized app settings

Full Transcript

In NestJS, custom configuration files are created by exporting a function that returns an object with settings like port and database details. This function is imported and loaded into the ConfigModule using the load option. The ConfigService is then injected into services or controllers to access these config values using the get method. Nested values can be accessed with dot notation. This approach allows dynamic and centralized configuration management for the app. The execution steps show creating the config, loading it, injecting the service, and accessing values to start the app on the configured port.

Practice

1. What is the main purpose of using custom configuration files in a NestJS application?

easy

A. To write all logic inside configuration files

B. To keep app settings organized and separate from the main code

C. To replace the main app module

D. To store user data permanently

Solution

1. Step 1: Understand configuration role

   Custom configuration files are used to keep settings like API keys or database info separate from the main code.

2. Step 2: Identify the correct purpose

   This separation helps organize the app and makes it easier to change settings without touching code logic.

3. Final Answer:

   To keep app settings organized and separate from the main code -> Option B

4. Quick Check:

   Custom config files organize settings [OK]

Hint: Custom configs separate settings from code for clarity [OK]

Common Mistakes:

• Thinking config files hold app logic
• Confusing config files with database storage
• Assuming config files replace main modules

2. Which syntax correctly creates a named custom configuration file using registerAs in NestJS?

easy

A. export const config = registerAs('app', () => ({ port: 3000 }));

B. registerAs('app', { port: 3000 });

C. export default registerAs('app', () => ({ port: 3000 }));

D. registerAs('app', () => port: 3000);

Solution

1. Step 1: Understand registerAs usage

   The registerAs function takes a name and a function returning a config object.

2. Step 2: Check syntax correctness

   export const config = registerAs('app', () => ({ port: 3000 })); correctly exports a constant assigned to registerAs with a function returning an object.

3. Final Answer:

   export const config = registerAs('app', () => ({ port: 3000 })); -> Option A

4. Quick Check:

   registerAs needs a name and a function returning an object [OK]

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

Common Mistakes:

• Omitting export or const keywords
• Passing object directly instead of a function
• Incorrect arrow function syntax

3. Given this custom config file:

export const databaseConfig = registerAs('database', () => ({ host: 'localhost', port: 5432 }));

And this module setup:

ConfigModule.forRoot({ load: [databaseConfig] })

What will configService.get('database.host') return?

medium

A. Error: Config not found

B. 'database.host'

C. undefined

D. 'localhost'

Solution

1. Step 1: Understand config loading

   The databaseConfig is loaded into ConfigModule with load, making its keys accessible.

2. Step 2: Access nested config value

   Using configService.get('database.host') accesses the 'host' key inside the 'database' config, which is 'localhost'.

3. Final Answer:

   'localhost' -> Option D

4. Quick Check:

   Nested config keys return their values [OK]

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

Common Mistakes:

• Expecting the whole object instead of a value
• Using wrong key names
• Not loading config before accessing

4. What is wrong with this custom config file code?

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

medium

A. The config name 'app' is invalid

B. Missing import of registerAs

C. The arrow function does not return the object properly

D. The port value must be a string

Solution

1. Step 1: Check arrow function return

   The arrow function uses curly braces without a return statement, so it returns undefined instead of the object.

2. Step 2: Correct syntax for returning object

   To return an object directly, wrap it in parentheses: () => ({ port: 3000 }).

3. Final Answer:

   The arrow function does not return the object properly -> Option C

4. Quick Check:

   Arrow functions need parentheses to return objects directly [OK]

Hint: Wrap object in parentheses to return from arrow function [OK]

Common Mistakes:

• Using curly braces without return in arrow functions
• Assuming config name must be special
• Thinking port must be string

5. You want to create two custom config files, appConfig and dbConfig, and load both in your NestJS app. Which setup correctly loads and accesses the dbConfig.username value?

hard

A. Load both configs in ConfigModule.forRoot({ load: [appConfig, dbConfig] }) and get with configService.get('dbConfig.username')

B. Load only appConfig and get dbConfig.username directly

C. Load both configs but access dbConfig.username with configService.get('username')

D. Load configs separately in different modules without forRoot

Solution

1. Step 1: Load multiple configs together

   Use ConfigModule.forRoot({ load: [appConfig, dbConfig] }) to load both custom configs at app start.

2. Step 2: Access nested config by namespace

   Access dbConfig.username using configService.get('dbConfig.username') because configs are namespaced by their registration name.

3. Final Answer:

   Load both configs in ConfigModule.forRoot({ load: [appConfig, dbConfig] }) and get with configService.get('dbConfig.username') -> Option A

4. Quick Check:

   Load all configs and use namespaced keys to access [OK]

Hint: Load all configs in forRoot and use dot keys to access [OK]

Common Mistakes:

• Loading only one config but accessing another
• Accessing keys without namespace prefix
• Trying to load configs outside forRoot