Provider scope (default, request, transient) in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a provider is set to default scope in NestJS?

Consider a NestJS service provider with the default scope. What is the behavior of this provider when injected into multiple components?

NestJS

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

@Injectable()
export class MyService {
  id = Math.random();
}

// This service is injected into two different controllers or providers.

A A new instance of MyService is created every time it is injected.

B A new instance of MyService is created for each HTTP request.

C A single instance of MyService is shared across the entire application.

D MyService instances are created only once per module.

💡 Hint

Default scope means the provider is a singleton by default.

In NestJS, providers with default scope are singletons. This means only one instance is created and shared across the whole app.

❓ component_behavior

intermediate

How does a request-scoped provider behave in NestJS?

If a provider is set with request scope, what happens when multiple HTTP requests use this provider?

NestJS

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

@Injectable({ scope: Scope.REQUEST })
export class RequestService {
  id = Math.random();
}

// This service is injected into controllers handling HTTP requests.

A A new instance of RequestService is created for each HTTP request.

B A single instance is shared across all requests.

C A new instance is created every time the service is injected within the same request.

D Instances are created once per module load.

💡 Hint

Request scope means one instance per HTTP request.

Request-scoped providers create a new instance for each incoming HTTP request, ensuring isolated state per request.

❓ component_behavior

advanced

What is the behavior of a transient-scoped provider in NestJS?

A provider is marked with transient scope. What happens when it is injected multiple times in the same request?

NestJS

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

@Injectable({ scope: Scope.TRANSIENT })
export class TransientService {
  id = Math.random();
}

// Injected multiple times in the same request or component.

A A single instance is shared per HTTP request.

B A new instance is created every time the provider is injected.

C A single instance is shared across the entire app.

D Instances are created once per module.

💡 Hint

Transient scope means no instance sharing at all.

Transient providers create a new instance every time they are injected, even within the same request or component.

❓ state_output

advanced

What will be the output of the following NestJS provider instances' IDs?

Given these providers with different scopes, what will be the output of their id properties when injected twice in the same request?

NestJS

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

@Injectable()
export class DefaultService {
  id = Math.random();
}

@Injectable({ scope: Scope.REQUEST })
export class RequestService {
  id = Math.random();
}

@Injectable({ scope: Scope.TRANSIENT })
export class TransientService {
  id = Math.random();
}

// Assume these are injected twice in the same request and their ids logged.

A DefaultService ids are same, RequestService ids are same, TransientService ids are different.

B All three services have different ids each time they are injected.

C DefaultService ids same, RequestService ids differ, TransientService ids same.

D DefaultService ids differ, RequestService ids differ, TransientService ids are same.

💡 Hint

Think about how many instances each scope creates per injection or request.

Default scope creates one instance shared everywhere, so ids are same. Request scope creates one instance per request, so ids same within request. Transient creates new instance every injection, so ids differ.

❓ lifecycle

expert

Which provider scope causes the most frequent constructor calls in NestJS?

Consider a provider injected multiple times in various parts of an app. Which scope leads to the highest number of constructor executions?

A Singleton scope

B Request scope

C Default scope

D Transient scope

💡 Hint

Think about how often new instances are created for each scope.

Transient scope creates a new instance every injection, causing the constructor to run most frequently.