Custom providers in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What will be the output of this NestJS custom provider injection?

Consider the following NestJS provider and service setup. What will be returned when AppService.getValue() is called?

NestJS

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

const MY_TOKEN = 'MY_TOKEN';

@Injectable()
export class AppService {
  constructor(@Inject(MY_TOKEN) private readonly value: string) {}

  getValue() {
    return this.value;
  }
}

export const myProvider = {
  provide: MY_TOKEN,
  useValue: 'Hello, NestJS!'
};

A null

B undefined

C Throws a runtime error: No provider for MY_TOKEN

D 'Hello, NestJS!'

💡 Hint

Think about how the useValue property works in custom providers.

The provider uses useValue to supply a fixed string 'Hello, NestJS!'. Injecting MY_TOKEN into AppService constructor assigns this string to value. So, getValue() returns 'Hello, NestJS!'.

📝 Syntax

intermediate

Which option correctly defines a custom provider using a factory function in NestJS?

You want to create a custom provider that returns a random number each time it is injected. Which option correctly defines this provider?

A { provide: 'RANDOM', useValue: () => Math.random() }

B { provide: 'RANDOM', useFactory: () => Math.random() }

C { provide: 'RANDOM', useFactory: Math.random }

D { provide: 'RANDOM', useClass: () => Math.random() }

💡 Hint

Remember that useFactory expects a function that returns the value.

Option B correctly uses useFactory with an arrow function returning a random number. Option B uses useValue which would inject the function itself, not the result. Option B passes Math.random directly, which works but is less clear and can cause context issues. Option B is invalid because useClass expects a class, not a function.

🔧 Debug

advanced

Why does this custom provider cause issues in NestJS?

Given this provider definition, what issue occurs when trying to inject 'CONFIG'?

export const configProvider = {
  provide: 'CONFIG',
  useFactory: () => {
    return fetchConfig();
  }
};

function fetchConfig() {
  return undefined;
}

A The factory returns undefined, so NestJS cannot inject a valid value.

B The provider token 'CONFIG' is not a valid symbol or class.

C The factory function is missing async keyword for fetchConfig.

D NestJS requires useClass for providers, not useFactory.

💡 Hint

Check what the factory function returns and how NestJS handles undefined values.

NestJS expects the factory to return a defined value. Returning undefined means the injection token 'CONFIG' has no usable value, resulting in undefined being injected which causes runtime errors when used.

❓ state_output

advanced

What are the values of count1 and count2 after injecting this custom provider twice?

Consider this provider and service:

let counter = 0;

export const counterProvider = {
  provide: 'COUNTER',
  useFactory: () => {
    counter += 1;
    return counter;
  }
};

@Injectable()
export class CounterService {
  constructor(@Inject('COUNTER') public count1: number, @Inject('COUNTER') public count2: number) {}
}

What are the values of count1 and count2 in CounterService?

A count1 = 1, count2 = 1

B count1 = 2, count2 = 2

C count1 = 1, count2 = 2

D count1 = 0, count2 = 0

💡 Hint

Think about how NestJS caches provider instances by default.

NestJS creates the provider once and reuses it. The factory runs once, increments counter to 1, and returns 1. Both injections receive the same value 1.

🧠 Conceptual

expert

Which statement about custom providers in NestJS is TRUE?

Select the correct statement about custom providers in NestJS.

A useValue providers are recreated every time they are injected.

B Custom providers must always use useClass to be injectable in NestJS.

C Custom providers using useFactory can inject other providers by listing them in the inject array.

D Custom providers cannot be scoped to request or transient lifetimes.

💡 Hint

Think about how dependencies are injected into factory providers.

Option C is true: useFactory providers can declare dependencies via the inject array to receive other providers. Option C is false because useFactory and useValue are valid. Option C is false because useValue providers are singletons. Option C is false because custom providers can be scoped.

Practice

1. What is the main purpose of a custom provider in NestJS?

easy

A. To manage database connections automatically

B. To define routes for HTTP requests

C. To control how NestJS creates or finds a service or value

D. To handle user authentication and authorization

Solution

1. Step 1: Understand the role of providers in NestJS

   Providers are responsible for creating and managing services or values that can be injected into other parts of the app.

2. Step 2: Identify what custom providers do

   Custom providers let you control exactly how NestJS creates or finds these services or values, making your app more flexible.

3. Final Answer:

   To control how NestJS creates or finds a service or value -> Option C

4. Quick Check:

   Custom provider purpose = control creation/finding [OK]

Hint: Custom providers control service creation or retrieval [OK]

Common Mistakes:

• Confusing providers with routing or middleware
• Thinking providers manage database or auth directly
• Assuming providers only register classes, not values or factories

2. Which of the following is the correct syntax to provide a custom value provider in a NestJS module?

easy

A. { provide: 'API_URL', useValue: 'https://api.example.com' }

B. { provide: 'API_URL', useClass: 'https://api.example.com' }

C. { provide: 'API_URL', useFactory: 'https://api.example.com' }

D. { provide: 'API_URL', useExisting: 'https://api.example.com' }

Solution

1. Step 1: Recall the syntax for value providers

   Value providers use the useValue key to assign a fixed value to a token.

2. Step 2: Check each option's correctness

   { provide: 'API_URL', useValue: 'https://api.example.com' } correctly uses useValue with a string value. Other options misuse useClass, useFactory, or useExisting which expect different types.

3. Final Answer:

   { provide: 'API_URL', useValue: 'https://api.example.com' } -> Option A

4. Quick Check:

   Value provider uses useValue = { provide: 'API_URL', useValue: 'https://api.example.com' } [OK]

Hint: Value providers always use 'useValue' key [OK]

Common Mistakes:

• Using useClass or useFactory for fixed values
• Confusing useExisting with useValue
• Putting string directly without useValue

3. Given the following provider configuration in a NestJS module:

{ provide: 'RANDOM_NUMBER', useFactory: () => Math.floor(Math.random() * 10) }

What will be the output if you inject 'RANDOM_NUMBER' twice in the same request?

medium

A. The same random number both times

B. Always zero because Math.random() is called once

C. An error because useFactory cannot be used this way

D. Two different random numbers between 0 and 9

Solution

1. Step 1: Understand provider scope and factory behavior

   By default, NestJS providers are singletons per application context, so the factory runs once and the result is reused.

2. Step 2: Analyze injection behavior

   Injecting 'RANDOM_NUMBER' twice in the same request returns the same value because the factory was called once at provider creation.

3. Final Answer:

   The same random number both times -> Option A

4. Quick Check:

   Singleton factory = same value injected [OK]

Hint: Default providers are singletons; factory runs once [OK]

Common Mistakes:

• Assuming factory runs on every injection
• Thinking useFactory causes errors without async
• Believing random number changes per injection

4. Consider this provider configuration:

{ provide: 'CONFIG', useFactory: () => ({ port: 3000 }) }

If you want to inject this provider but get an error "Nest can't resolve dependencies", what is the most likely cause?

medium

A. The token 'CONFIG' must be a class, not a string

B. The useFactory function must be async

C. You cannot use useFactory with object literals

D. The provider is missing from the module's providers array

Solution

1. Step 1: Check provider registration

   For NestJS to inject a provider, it must be registered in the module's providers array.

2. Step 2: Evaluate other options

   useFactory can be sync or async, tokens can be strings, and useFactory can return objects. The error usually means the provider is not registered.

3. Final Answer:

   The provider is missing from the module's providers array -> Option D

4. Quick Check:

   Missing provider registration = injection error [OK]

Hint: Always register providers in module's providers array [OK]

Common Mistakes:

• Assuming useFactory must be async
• Thinking tokens must be classes only
• Believing useFactory can't return objects

5. You want to create a custom provider that returns different database connection strings based on environment variables. Which approach correctly implements this using a factory provider in NestJS?

hard

A. { provide: 'DB_CONNECTION', useValue: process.env.NODE_ENV === 'prod' ? 'prod-db' : 'dev-db' }

B. { provide: 'DB_CONNECTION', useFactory: () => process.env.NODE_ENV === 'prod' ? 'prod-db' : 'dev-db' }

C. { provide: 'DB_CONNECTION', useClass: process.env.NODE_ENV === 'prod' ? ProdDbService : DevDbService }

D. { provide: 'DB_CONNECTION', useExisting: process.env.NODE_ENV === 'prod' ? 'ProdDbService' : 'DevDbService' }

Solution

1. Step 1: Understand dynamic value creation

   To choose a value based on environment variables at runtime, a factory provider is ideal because it runs code to decide the value.

2. Step 2: Evaluate each option

   { provide: 'DB_CONNECTION', useFactory: () => process.env.NODE_ENV === 'prod' ? 'prod-db' : 'dev-db' } uses useFactory with a function that returns the correct string based on process.env.NODE_ENV. { provide: 'DB_CONNECTION', useValue: process.env.NODE_ENV === 'prod' ? 'prod-db' : 'dev-db' } uses useValue which is static at module load time. Options C and D misuse useClass and useExisting with strings or conditions incorrectly.

3. Final Answer:

   { provide: 'DB_CONNECTION', useFactory: () => process.env.NODE_ENV === 'prod' ? 'prod-db' : 'dev-db' } -> Option B

4. Quick Check:

   Dynamic values need useFactory with runtime logic [OK]

Hint: Use useFactory for runtime-dependent values [OK]

Common Mistakes:

• Using useValue for dynamic environment-based values
• Misusing useClass or useExisting with strings
• Expecting useFactory to be static