Constructor injection in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this NestJS service using constructor injection?

Consider this NestJS service that injects a repository via constructor injection. What will be logged when getData() is called?

NestJS

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

@Injectable()
export class DataService {
  constructor(private readonly repo: { find: () => string }) {}

  getData() {
    return this.repo.find();
  }
}

const fakeRepo = { find: () => 'data found' };
const service = new DataService(fakeRepo);
console.log(service.getData());

A SyntaxError

B "undefined"

C "data found"

D TypeError: this.repo.find is not a function

💡 Hint

Constructor injection assigns the passed object to the private readonly property repo.

The DataService receives fakeRepo via constructor injection. The getData() method calls repo.find(), which returns the string "data found".

📝 Syntax

intermediate

Which option correctly injects a service using NestJS constructor injection?

Choose the correct syntax for injecting MyService into AppService using constructor injection.

A constructor(private readonly myService: MyService) {}

B constructor(private myService: MyService) {}

C constructor(myService: MyService) { this.myService = myService; }

D constructor(public myService: MyService) {}

💡 Hint

Use private readonly to declare and assign the injected service in one step.

Option A uses private readonly which is the recommended pattern in NestJS for constructor injection. It declares and assigns the service as a private readonly property.

🔧 Debug

advanced

Why does this NestJS service throw an error when using constructor injection?

Given this service, why does NestJS throw a runtime error about missing dependencies?

NestJS

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

@Injectable()
export class UserService {
  constructor(private readonly repo) {}

  getUser() {
    return this.repo.findUser();
  }
}

A The constructor parameter lacks a type, so NestJS cannot resolve the dependency.

B The repo property should be public, not private readonly.

C The @Injectable decorator is missing from the repo class.

D The getUser method must be async to use the repo.

💡 Hint

Check if NestJS can identify the dependency type from the constructor.

Without a type annotation, NestJS cannot know what to inject for repo. The constructor parameter must have a type for NestJS to resolve the dependency.

❓ state_output

advanced

What is the value of the injected service property after instantiation?

In this NestJS controller, what will be the value of this.authService.isLoggedIn after the constructor runs?

NestJS

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

class AuthService {
  isLoggedIn = false;
}

@Controller()
export class AuthController {
  constructor(private readonly authService: AuthService) {
    this.authService.isLoggedIn = true;
  }
}

A undefined

B false

C Throws ReferenceError

D true

💡 Hint

The constructor sets isLoggedIn to true explicitly.

The authService instance is injected and its isLoggedIn property is set to true in the constructor, so its value is true after instantiation.

🧠 Conceptual

expert

Which statement best describes constructor injection in NestJS?

Choose the most accurate description of how constructor injection works in NestJS.

A Constructor injection requires manually creating instances and passing them to the constructor when creating a class.

B NestJS uses the constructor parameter types to automatically resolve and inject dependencies registered in its module system.

C Dependencies must be injected via setter methods after the class is instantiated.

D NestJS only supports property injection, not constructor injection.

💡 Hint

Think about how NestJS uses TypeScript metadata to inject services.

NestJS reads the types of constructor parameters and uses its dependency injection container to provide instances automatically. This is the core of constructor injection in NestJS.