Async configuration in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this async configuration in NestJS?

Consider this NestJS module configuration using async factory. What will be logged when the application starts?

NestJS

import { Module } from '@nestjs/common';

@Module({
  imports: [],
  providers: [
    {
      provide: 'CONFIG',
      useFactory: async () => {
        console.log('Loading config...');
        await new Promise(resolve => setTimeout(resolve, 100));
        console.log('Config loaded');
        return { key: 'value' };
      },
    },
  ],
})
export class AppModule {}

A Error: useFactory cannot be async

B Config loaded\nLoading config...

C No output because useFactory is async

D Loading config...\nConfig loaded

💡 Hint

Think about how async functions execute and when console.log statements run.

The async useFactory runs immediately when the provider is created. The first console.log runs before the await, so 'Loading config...' prints first. After the await delay, 'Config loaded' prints. So the output is those two lines in order.

❓ state_output

intermediate

What value does the injected config have after async initialization?

Given this async config provider in NestJS, what is the value injected into dependent services?

NestJS

import { Module, Inject, Injectable } from '@nestjs/common';

@Injectable()
class Service {
  constructor(@Inject('CONFIG') public config: any) {}
}

@Module({
  providers: [
    {
      provide: 'CONFIG',
      useFactory: async () => {
        return new Promise(resolve => {
          setTimeout(() => resolve({ port: 3000 }), 50);
        });
      },
    },
    Service,
  ],
})
export class AppModule {}

A { port: 3000 }

B Promise { <pending> }

C undefined

D Error: Cannot inject async provider

💡 Hint

Remember NestJS waits for async providers to resolve before injection.

NestJS resolves async providers before injecting them. So the injected value is the resolved object { port: 3000 }, not a Promise or undefined.

📝 Syntax

advanced

Which option correctly uses async configuration with ConfigModule.forRoot?

Select the correct async configuration syntax for ConfigModule in NestJS.

NestJS

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

@Module({
  imports: [
    ConfigModule.forRoot({
      // async config here
    }),
  ],
})
export class AppModule {}

A useFactory: async () => ({ envFilePath: '.env' })

B useFactory: () => { envFilePath: '.env' }

C useFactory: async () => { return { envFilePath: '.env' } }

D useFactory: () => Promise.resolve({ envFilePath: '.env' })

💡 Hint

Check which option returns the config object correctly from an async function.

Option C correctly defines an async function returning the config object with explicit return. Option C misses return statement (implicit return with parentheses is valid but here it's an object literal, so parentheses needed). Option C returns a Promise but not async function syntax. Option C returns undefined because no return statement.

🔧 Debug

advanced

Why does this async config provider cause a runtime error?

Identify the cause of the runtime error in this async provider code.

NestJS

providers: [
  {
    provide: 'CONFIG',
    useFactory: () => {
      const config = await fetchConfig();
      return config;
    },
  },
],

async function fetchConfig() {
  return { key: 'value' };
}

A Config is undefined

B SyntaxError: 'await' used outside async function

C fetchConfig is not defined

D No error, runs fine

💡 Hint

Check if the function using await is declared async.

The useFactory function is not marked async but uses await inside, causing a SyntaxError.

🧠 Conceptual

expert

What happens if multiple async config providers depend on each other circularly?

In NestJS, if two async providers depend on each other (circular dependency) during async configuration, what is the expected behavior?

A NestJS throws a runtime error about circular dependency

B Both providers resolve successfully without issues

C One provider resolves, the other remains pending forever

D NestJS automatically breaks the cycle and injects partial values

💡 Hint

Think about how dependency injection handles circular references.

NestJS detects circular dependencies and throws a runtime error to prevent infinite loops during provider resolution.