NestJS Interview Questions with Answers

NestJS is a robust and versatile Node.js framework tailored for developing scalable and efficient server-side applications. With its popularity soaring, mastering common interview questions can give you an edge. Here's a list of frequently asked NestJS interview questions, along with detailed answers.

1. What is NestJS? Why is it used?

Answer:

NestJS is an innovative Node.js framework designed to create efficient, dependable, and scalable server-side applications. It leverages TypeScript, enabling developers to write clean, strongly-typed code.

Key Features:

• Dependency injection system
• Modular architecture
• Support for microservices
• Built-in tools for testing

2. What are the core principles of NestJS?

Answer:

1. Modularity: Organizes the application into small, reusable modules.
2. Dependency Injection (DI): Provides a robust DI container for managing class dependencies.
3. Decorators: Enhances code readability and functionality using TypeScript decorators.

3. What is the purpose of a module in NestJS?

Answer:

A module is a container for controllers and providers that group related functionalities. Every NestJS application lies a primary root module that serves as the entry point for the application’s execution.

Example:

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

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

4. Explain dependency injection in NestJS.

Answer:

Dependency Injection (DI) is a software design approach that facilitates the seamless management and injection of class dependencies. NestJS uses DI to inject service instances into controllers or other services automatically.

Example:

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

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}

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

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  getHello(): string {
    return this.appService.getHello();
  }
}

5. What are controllers in NestJS?

Answer:

Controllers handle incoming requests and return responses. They define routes and are decorated with the @Controller decorator.

Example:

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

@Controller('users')
export class UsersController {
  @Get()
  findAll(): string {
    return 'This action returns all users';
  }
}

6. How do you create a custom provider in NestJS?

Answer:

Custom providers can be used for advanced DI scenarios.

Example:

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

@Injectable()
export class CustomService {
  sayHello(): string {
    return 'Hello from CustomService';
  }
}

const CustomProvider = {
  provide: 'CUSTOM_SERVICE',
  useClass: CustomService,
};

7. What is middleware in NestJS, and how is it implemented?

Answer:

In NestJS, middleware operates within the request-response cycle.

Example:

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

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {
    console.log('Request...');
    next();
  }
}

To apply middleware:

import { Module, MiddlewareConsumer, RequestMethod } from '@nestjs/common';

@Module({})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(LoggerMiddleware).forRoutes({ path: '*', method: RequestMethod.ALL });
  }
}

8. How are exceptions handled in NestJS?

Answer:

NestJS uses an inbuilt exception filter mechanism. Developers can create custom exception filters using @Catch decorator.

Example:

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';

@Catch(HttpException)
export class CustomExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const status = exception.getStatus();

    response.status(status).json({
      statusCode: status,
      message: exception.message,
    });
  }
}

9. What is the difference between useClass, useValue, and useFactory in providers?

Answer:

1. useClass: Specifies a class to be instantiated by the DI container.
2. useValue: Provides a static value.
3. useFactory: Uses a factory function to generate the value.

Example:

const factoryProvider = {
  provide: 'ASYNC_PROVIDER',
  useFactory: async () => {
    return await Promise.resolve('Dynamic Value');
  },
};

10. How does NestJS support WebSockets?

Answer:

NestJS has built-in support for WebSockets using @WebSocketGateway and @SubscribeMessage.

Example:

import { WebSocketGateway, SubscribeMessage, MessageBody } from '@nestjs/websockets';

@WebSocketGateway()
export class ChatGateway {
  @SubscribeMessage('message')
  handleMessage(@MessageBody() data: string): string {
    return `Received: ${data}`;
  }
}

11. What is the purpose of pipes in NestJS?

Answer:

Pipes in NestJS play a pivotal role in handling incoming data by transforming or validating it before the application processes it further.

Example:

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

@Injectable()
export class ValidationPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    if (!value) throw new Error('Validation failed!');
    return value;
  }
}

12. How do you implement Guards in NestJS?

Answer:

Guards in NestJS act as gatekeepers, controlling whether a specific route handler can be executed based on custom-defined conditions.

Example:

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

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    return request.headers.authorization === 'Bearer token';
  }
}

Conclusion

These NestJS interview questions cover core concepts to advanced features, helping you prepare effectively. For a deeper dive, explore the NestJS Documentation for real-world implementations.