What is @nestjs/common?
The @nestjs/common package is a core part of the NestJS framework, which is a framework for building efficient, reliable and scalable server-side applications. This package provides a wide range of basic functionalities necessary for any NestJS application, including decorators, modules, middleware, filters, pipes, guards, and utilities for handling HTTP requests and responses.
What are @nestjs/common's main functionalities?
Decorators
Decorators are used to annotate classes and their members to define their roles within the application. For example, `@Injectable()` marks a class as a service that can be injected, and `@Controller()` defines a class as a controller with a specific route.
@Injectable()
class MyService {}
@Controller('my-route')
class MyController {
constructor(private myService: MyService) {}
}
Modules
Modules are used to organize components by encapsulating them within bounded contexts. This code sample demonstrates how to define a module that includes controllers and providers.
@Module({
imports: [],
controllers: [MyController],
providers: [MyService],
})
class MyModule {}
Middleware
Middleware are functions that execute during the request-response cycle. They can perform tasks like logging, request validation, etc. This code sample shows a basic middleware that logs a message on each request.
@Injectable()
class MyMiddleware implements NestMiddleware {
use(req: Request, res: Response, next: NextFunction) {
console.log('Request...');
next();
}
}
Exception Filters
Exception filters handle exceptions that occur during the processing of a request. This code sample demonstrates a filter that catches HTTP exceptions and formats the response.
@Catch(HttpException)
class HttpExceptionFilter implements ExceptionFilter {
catch(exception: HttpException, host: ArgumentsHost) {
const ctx = host.switchToHttp();
const response = ctx.getResponse<Response>();
const status = exception.getStatus();
response
.status(status)
.json({
statusCode: status,
timestamp: new Date().toISOString(),
path: ctx.getRequest<Request>().url,
});
}
}
Other packages similar to @nestjs/common
express
Express is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications. While it serves a similar purpose in building server-side applications, it is less opinionated than NestJS and does not provide the same level of structure and abstraction out of the box.
koa
Koa is a new web framework designed by the team behind Express, aiming to be a smaller, more expressive, and more robust foundation for web applications and APIs. Koa uses async functions, which allows for a simpler and more powerful way to handle asynchronous operations compared to Express. However, like Express, it is less opinionated than NestJS.
hapi
Hapi is a rich framework for building applications and services, allowing developers to focus on writing reusable application logic instead of spending time building infrastructure. It is designed to be more configurable and extensible than Express, offering a more comprehensive set of features out of the box. However, it still lacks the full-fledged module system and decorators provided by NestJS.