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.