First NestJS application - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this simple NestJS controller?

Consider this NestJS controller code. What will be the HTTP response body when a GET request is made to the root path '/'?

NestJS

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

@Controller()
export class AppController {
  @Get()
  getHello(): string {
    return 'Hello, NestJS!';
  }
}

A "Hello, NestJS!"

B "{ message: 'Hello, NestJS!' }"

C An empty response with status 200

D A 404 Not Found error

💡 Hint

Look at the return value of the getHello() method and how NestJS sends it as the response body.

The getHello() method returns a string. NestJS sends this string as the HTTP response body directly, so the client receives "Hello, NestJS!".

❓ state_output

intermediate

What is the value of 'count' after three POST requests?

Given this NestJS service and controller, what will be the value of 'count' after three POST requests to '/increment'?

NestJS

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

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

  increment() {
    this.count++;
    return this.count;
  }

  getCount() {
    return this.count;
  }
}

@Controller()
export class CounterController {
  constructor(private readonly counterService: CounterService) {}

  @Post('increment')
  increment() {
    return this.counterService.increment();
  }
}

A An error occurs because 'count' is private

B 3

C 1

D 0

💡 Hint

The service instance is shared and 'count' is incremented each time increment() is called.

The CounterService is a singleton by default in NestJS. Each POST request calls increment(), increasing 'count' by 1. After three calls, 'count' is 3.

📝 Syntax

advanced

Which option correctly defines a NestJS module with a controller and service?

Identify the correct NestJS module definition that properly imports the controller and service.

A

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

B

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [AppController],
  providers: [AppService],
})
export class AppModule {}

C

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  controllers: [AppService],
  providers: [AppController],
})
export class AppModule {}

D

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  controllers: AppController,
  providers: AppService,
})
export class AppModule {}

💡 Hint

Controllers go in 'controllers' array, services in 'providers' array, both as arrays.

The @Module decorator expects arrays for 'controllers' and 'providers'. Option A correctly assigns AppController to controllers and AppService to providers as arrays.

🔧 Debug

advanced

Why does this NestJS app throw a runtime error on startup?

Given this code snippet, why does the NestJS application fail to start?

NestJS

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  controllers: [AppController],
  providers: [],
})
export class AppModule {}

A AppController is missing from controllers array

B The import statements are incorrect

C The @Module decorator is missing parentheses

D AppService is not listed in providers, so dependency injection fails if AppController depends on it

💡 Hint

Check if all dependencies used by controllers are provided in the module.

If AppController injects AppService but AppService is not in providers, NestJS cannot resolve the dependency, causing a runtime error.

🧠 Conceptual

expert

What happens if you mark a NestJS service as @Injectable({ scope: Scope.REQUEST })?

In NestJS, what is the effect of setting a service's scope to REQUEST using @Injectable({ scope: Scope.REQUEST })?

NestJS

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

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

  getId() {
    return this.id;
  }
}

A The service is not injectable and causes a compile-time error

B The service behaves as a singleton shared across all requests

C A new instance of the service is created for each incoming HTTP request

D The service instance is created once per application startup

💡 Hint

Think about how scope affects instance creation in NestJS.

Setting scope to REQUEST means NestJS creates a fresh instance of the service for every HTTP request, isolating state per request.