Service creation in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this NestJS service method call?

Consider this NestJS service method that returns a greeting message. What will be the output when getGreeting() is called?

NestJS

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

@Injectable()
export class GreetingService {
  getGreeting(): string {
    return `Hello, NestJS!`;
  }
}

const service = new GreetingService();
console.log(service.getGreeting());

A Hello, NestJS!

B undefined

C Error: Cannot read property 'getGreeting' of undefined

D Hello, World!

💡 Hint

Look at the return statement inside the getGreeting method.

The getGreeting method returns the string 'Hello, NestJS!'. When called, it outputs exactly that string.

📝 Syntax

intermediate

Which option correctly defines a NestJS service with dependency injection?

You want to create a NestJS service OrderService that depends on PaymentService. Which option correctly injects PaymentService into OrderService?

A

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

export class OrderService {
  constructor(private paymentService: PaymentService) {}
}

B

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

@Injectable()
export class OrderService {
  paymentService: PaymentService;
  constructor() {
    this.paymentService = new PaymentService();
  }
}

C

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

@Injectable()
export class OrderService {
  constructor(private paymentService: PaymentService) {}
}

D

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

@Injectable()
export class OrderService {
  constructor(paymentService: PaymentService) {
    this.paymentService = paymentService;
  }
}

💡 Hint

Look for the correct use of @Injectable and constructor parameter visibility.

Option C uses @Injectable decorator and declares the dependency in the constructor with 'private' keyword, which automatically assigns it as a class property and enables NestJS to inject it.

🔧 Debug

advanced

Why does this NestJS service fail to inject the dependency?

Given the following code, why will NestJS fail to inject UserRepository into UserService?

NestJS

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

@Injectable()
export class UserService {
  constructor(private userRepository: UserRepository) {}
}

@Injectable()
export class UserRepository {}

A UserService is missing the @Controller decorator.

B The constructor parameter should be public, not private.

C UserRepository must be imported from a module, not declared in the same file.

D UserRepository is not decorated with @Injectable(), so NestJS cannot inject it.

💡 Hint

Check if all injectable classes have the @Injectable decorator.

NestJS requires all injectable classes to have the @Injectable decorator to register them in the dependency injection system. UserRepository lacks this decorator, so injection fails.

❓ state_output

advanced

What is the value of count after calling increment() twice?

Consider this NestJS service that tracks a count. What will be the value of count after calling increment() two times?

NestJS

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

@Injectable()
export class CounterService {
  private count = 0;

  increment() {
    this.count++;
  }

  getCount() {
    return this.count;
  }
}

const service = new CounterService();
service.increment();
service.increment();
const result = service.getCount();

A 1

B 2

C 0

D undefined

💡 Hint

Each call to increment increases count by one.

The count starts at 0. Each increment call adds 1. After two calls, count is 2.

🧠 Conceptual

expert

Which statement best describes the role of services in NestJS?

In NestJS, what is the primary purpose of a service?

A To encapsulate business logic and provide reusable functionality.

B To style components and manage UI layout.

C To manage database connections directly without abstraction.

D To handle HTTP requests and define routes.

💡 Hint

Think about where the core logic of your app should live.

Services in NestJS are designed to hold business logic and reusable code, separate from controllers which handle HTTP requests.