NestJs Questions

Pramesh Singh

Score: 🔥 32

Beginner

Took 2 months

Programming Framework

NestJs

73%

Questions Attempted

15 / 15

Correct Answers

Incorrect Answers

Points Earned

🔥 11

Question 1

What is the role of the 'main.ts' file in a NestJS project?

Defines the application's database schema and models
Contains unit tests for the application's logic
Creates and configures the NestJS application instance
Stores environment variables and configuration settings

Explanation:

The main.ts file is the entry point of your NestJS application. It bootstraps the NestJS application, often setting up the listening port and other core configurations.

Question 2

What is NOT a benefit of using Dependency Injection in NestJS?

Improved code testability.
Increased code coupling.
Enhanced code reusability.
Better maintainability of code.

Explanation:

Dependency Injection promotes loose coupling, not increased coupling. It allows components to depend on abstractions (interfaces) rather than concrete implementations.

Question 3

Which decorator is used to define a controller in NestJS?

@Injectable()
@Module()
@Controller()
@Component()

Explanation:

The @Controller() decorator is essential for marking a class as a controller. This enables NestJS to recognize it as a handler for incoming HTTP requests.

Question 4

Which decorator is used to mark a class as a provider in NestJS?

@Controller()
@Module()
@Service()
@Injectable()

Explanation:

The @Injectable() decorator is crucial for making a class available for dependency injection. This informs NestJS that the class can be provided as a dependency to other components.

Question 5

What is a potential drawback of using singleton providers excessively in a large application?

Increased memory usage due to persistent instances.
Slower application startup time.
Difficulty in testing individual components.
All of the above.

Explanation:

While singletons offer benefits like shared state and reduced instantiation overhead, overusing them can lead to increased memory usage (as instances persist), slower startup (due to potential initialization chains), and challenges in isolating components during testing.

Question 6

Which programming language forms the foundation of NestJS?

Python
Java
JavaScript/TypeScript
Ruby

Explanation:

NestJS is built on top of Node.js, and it primarily uses either JavaScript or TypeScript (a superset of JavaScript) for building applications.

Question 7

What is the primary function of middleware in NestJS?

To handle database operations.
To define API routes.
To intercept and modify incoming requests and outgoing responses.
To render dynamic views on the server.

Explanation:

Middleware in NestJS acts as a bridge between incoming requests and the route handlers. It allows you to perform tasks like logging, authentication, or data transformation before the request reaches the controller.

Question 8

How does Dependency Injection work in NestJS?

Dependencies are manually created and passed around.
NestJS automatically resolves and injects dependencies based on constructor parameters.
Dependency Injection is not supported in NestJS.
Dependencies are fetched from a global configuration file.

Explanation:

Dependency Injection in NestJS is handled by its internal injector. When a component (like a controller) has a dependency specified in its constructor, the injector automatically resolves and provides an instance of that dependency.

Question 9

When would you choose to create a custom exception filter instead of using a built-in one?

When you need to implement specific error logging or response formatting for unique situations.
When you want to handle all exceptions in a single, centralized location.
When you are working with a database that is not supported by NestJS.
When you need to integrate with an external error monitoring service.

Explanation:

Custom filters provide the flexibility to tailor error responses, logging, or any specific actions needed for particular exception scenarios in your application.

Question 10

What is the order of execution for middleware applied at the controller and route level in NestJS?

Route-level middleware executes first, followed by controller-level middleware.
Controller-level middleware executes first, followed by route-level middleware.
The order of execution is undefined.
The order can be controlled using a priority setting.

Explanation:

In NestJS, middleware follows a specific execution order. When a request arrives, any middleware applied at the controller level is executed first. Afterward, the middleware specific to the requested route is executed.

Question 11

When using an Interceptor to modify the response, what is the best way to ensure type safety?

Type casting within the Interceptor.
Using generics with the NestInterceptor interface.
Disabling type checks within the Interceptor.
Type checking is not necessary within Interceptors.

Explanation:

For type safety, define generics with the NestInterceptor interface, specifying the expected request and response types, allowing TypeScript to perform type checking.

Question 12

What is the purpose of the @Get() decorator in NestJS?

Handles POST requests
Handles PUT requests
Handles DELETE requests
Handles GET requests

Explanation:

The @Get() decorator is used to mark a controller method as a handler for incoming HTTP GET requests. It specifies that the method should be invoked when a GET request is made to the associated route.

Question 13

What is the advantage of using built-in HTTP exception filters in NestJS?

They provide a streamlined way to handle common HTTP errors with predefined responses.
They allow you to bypass the need for exception handling altogether.
They are only applicable for database-related exceptions.
They are primarily used for handling authentication and authorization errors.

Explanation:

NestJS's built-in filters simplify error handling by providing ready-to-use responses for standard HTTP errors, reducing the need for repetitive code.

Question 14

What is the role of the next() function in NestJS middleware?

To terminate the request-response cycle.
To pass control to the next middleware in the stack or the route handler.
To send a response back to the client.
To log information about the request.

Explanation:

The next() function is crucial for controlling the flow within middleware. Calling next() delegates the responsibility to the subsequent middleware in line or, if it's the last middleware, to the route handler.

Question 15

Which decorator is used to define an Interceptor class in NestJS?

@Injectable()
@Controller()
@Interceptor()
@Module()

Explanation:

The @Interceptor() decorator from @nestjs/common is specifically designed to mark a class as an Interceptor in NestJS.