Custom providers in NestJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a custom provider in NestJS?

A custom provider in NestJS is a way to define how a dependency is created or supplied, allowing you to control the instance or value injected into your classes.

beginner

How do you define a custom provider using the 'useValue' syntax?

You define a custom provider by specifying an object with a 'provide' key for the token and a 'useValue' key for the fixed value to inject, like { provide: 'TOKEN', useValue: someValue }.

intermediate

Explain the difference between 'useClass' and 'useFactory' in custom providers.

'useClass' tells NestJS to instantiate a specific class when injecting, while 'useFactory' lets you provide a function that returns the value or instance, allowing dynamic or async creation.

intermediate

What is the purpose of the 'inject' array in a custom provider using 'useFactory'?

The 'inject' array lists the dependencies that NestJS should pass as arguments to the factory function, enabling you to use other providers inside your factory.

intermediate

Why would you use a custom provider instead of a regular service class in NestJS?

Custom providers let you control exactly how and what is injected, useful for injecting constants, third-party libraries, or creating dynamic or mocked instances for testing.

Which property do you use to provide a fixed value in a custom provider?

A useFactory

B useClass

C useValue

D useExisting

The 'useValue' property is used to provide a fixed value directly as the provider.

What does the 'useClass' property do in a custom provider?

A Specifies a class to instantiate

B Reuses an existing provider

C Defines a factory function

D Returns a fixed value

'useClass' tells NestJS to instantiate the given class when injecting.

How do you inject dependencies into a factory function in a custom provider?

A Using 'useClass'

B Using the 'inject' array

C Using 'useValue'

D Using 'provide'

The 'inject' array lists dependencies to pass as arguments to the factory function.

Which custom provider type allows asynchronous creation of the injected value?

A useFactory

B useClass

C useValue

D useExisting

'useFactory' can return a Promise, enabling async creation.

What is a common use case for custom providers in NestJS?

A To create UI components

B To style HTML elements

C To write SQL queries

D To control dependency injection behavior

Custom providers let you control how dependencies are created and injected.

Describe how to create a custom provider in NestJS using 'useFactory' and explain when you might use it.

Think about when you need to create a value dynamically or asynchronously.

Explain the differences between 'useValue', 'useClass', and 'useFactory' in NestJS custom providers.

Consider how each method controls what gets injected.

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