Custom providers in NestJS - Mini Project: Build & Apply

Creating and Using Custom Providers in NestJS

📖 Scenario: You are building a simple NestJS application that needs to provide a greeting message. Instead of hardcoding the greeting, you want to use a custom provider to supply the greeting text. This approach helps keep your code flexible and easy to change later.

🎯 Goal: Build a NestJS module that uses a custom provider named GREETING to supply a greeting string. Then inject this provider into a service to return the greeting message.

📋 What You'll Learn

Create a custom provider named GREETING with the value 'Hello, NestJS!'

Create a service called GreetingService that injects the GREETING provider

Add a method getGreeting() in GreetingService that returns the injected greeting string

Register the custom provider and the service in a module called AppModule

💡 Why This Matters

🌍 Real World

Custom providers in NestJS allow you to inject values, classes, or factories that are not standard services. This is useful for configuration values, constants, or third-party libraries.

💼 Career

Understanding custom providers is essential for building scalable and maintainable NestJS applications, a skill often required for backend developer roles using Node.js and NestJS.

1

Create the custom provider with the greeting string

Create a constant called GREETING and set it to the string 'Hello, NestJS!'. Then create a provider object called greetingProvider with the key provide set to GREETING and useValue set to 'Hello, NestJS!'.

NestJS

# Create the GREETING constant and greetingProvider object
# Your code here

Hint

Remember, a custom provider in NestJS is an object with provide and useValue keys.

2

Create the GreetingService that injects the custom provider

Create a class called GreetingService. Use the @Injectable() decorator. Add a constructor that injects the GREETING provider using @Inject(GREETING) and stores it in a private readonly variable called greeting.

NestJS

export const GREETING = 'GREETING';

export const greetingProvider = {
  provide: GREETING,
  useValue: 'Hello, NestJS!'
};

// Create GreetingService with @Injectable and inject GREETING
# Your code here

Hint

Use @Inject(GREETING) in the constructor parameter to inject the custom provider.

3

Add a method to return the greeting string

Inside the GreetingService class, add a method called getGreeting() that returns the private greeting string.

NestJS

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

export const GREETING = 'GREETING';

export const greetingProvider = {
  provide: GREETING,
  useValue: 'Hello, NestJS!'
};

@Injectable()
export class GreetingService {
  constructor(@Inject(GREETING) private readonly greeting: string) {}

  // Add getGreeting() method here
  # Your code here
}

Hint

The method should simply return the injected greeting string.

4

Register the provider and service in AppModule

Create a class called AppModule with the @Module() decorator. Inside the decorator, add providers array containing greetingProvider and GreetingService. Export the AppModule class.

NestJS

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

export const GREETING = 'GREETING';

export const greetingProvider = {
  provide: GREETING,
  useValue: 'Hello, NestJS!'
};

@Injectable()
export class GreetingService {
  constructor(@Inject(GREETING) private readonly greeting: string) {}

  getGreeting(): string {
    return this.greeting;
  }
}

// Create AppModule and register greetingProvider and GreetingService
# Your code here

Hint

Use the @Module() decorator to register providers and services.

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