Decorator-based architecture in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this NestJS controller method?

Consider this NestJS controller method decorated with @Get and @UseGuards. What will be the HTTP response status code when this endpoint is accessed successfully?

NestJS

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

@Controller('items')
export class ItemsController {
  @Get()
  @UseGuards(AuthGuard('jwt'))
  findAll() {
    return { message: 'Items fetched' };
  }
}

A 200 OK with JSON { message: 'Items fetched' }

B 401 Unauthorized error

C 404 Not Found error

D 500 Internal Server Error

💡 Hint

Think about what @UseGuards(AuthGuard('jwt')) does when the user is authenticated.

The @Get decorator defines an HTTP GET endpoint. The @UseGuards with AuthGuard('jwt') protects the route, allowing only authenticated requests. If authentication succeeds, the method returns the JSON with status 200 OK.

📝 Syntax

intermediate

Which option correctly applies a custom decorator to inject a user object in NestJS?

You want to create a custom decorator @CurrentUser() that extracts the user from the request object. Which option correctly defines and uses this decorator in a controller method?

NestJS

import { createParamDecorator, ExecutionContext } from '@nestjs/common';

export const CurrentUser = createParamDecorator((data: unknown, ctx: ExecutionContext) => {
  const request = ctx.switchToHttp().getRequest();
  return request.user;
});

@Controller('profile')
export class ProfileController {
  @Get()
  getProfile(@CurrentUser() user) {
    return user;
  }
}

A Correct as shown in the code above

B Replace createParamDecorator with @Injectable decorator

C Use @Param('user') instead of @CurrentUser()

D Define CurrentUser as a class instead of a function

💡 Hint

Custom parameter decorators use createParamDecorator function.

The createParamDecorator function is the correct way to create a custom parameter decorator in NestJS. It accesses the request object via ExecutionContext and returns the user property.

🔧 Debug

advanced

Why does this NestJS service fail to inject the repository?

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

NestJS

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(@InjectRepository(User) private userRepository: Repository<User>) {}

  findAll() {
    return this.userRepository.find();
  }
}

A The findAll method is missing async keyword

B The @Injectable decorator is missing

C The User entity is not imported correctly

D The constructor parameter is missing @InjectRepository(User) decorator

💡 Hint

Check how TypeORM repositories are injected in NestJS services.

When injecting a repository, you must use @InjectRepository(Entity) on the constructor parameter. Without it, NestJS cannot resolve the dependency.

❓ lifecycle

advanced

What happens when a NestJS provider implements OnModuleInit?

If a service class implements the OnModuleInit interface and defines the onModuleInit() method, when is this method called?

NestJS

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

@Injectable()
export class AppService implements OnModuleInit {
  onModuleInit() {
    console.log('Module initialized');
  }
}

A Called every time a request is received

B Called once after the module's providers are initialized

C Called only when the application shuts down

D Called before the module's providers are created

💡 Hint

Think about the lifecycle of modules and providers in NestJS.

The onModuleInit() method is called once after all providers in the module have been initialized, allowing setup logic after injection.

🧠 Conceptual

expert

Which option best describes the role of decorators in NestJS architecture?

In NestJS, decorators like @Controller, @Injectable, and @Module are used extensively. What is their primary purpose in the framework's architecture?

A They execute code immediately to modify class behavior at runtime

B They replace the need for writing any configuration files

C They add metadata to classes and methods to enable dependency injection and routing

D They automatically generate database schemas from classes

💡 Hint

Think about how NestJS uses decorators to organize and connect parts of the app.

Decorators in NestJS add metadata that the framework reads to perform dependency injection, routing, and module organization. They do not execute code immediately or generate schemas automatically.