Announcing NestJS 11: What’s New?

NestJS, the progressive Node.js framework for building efficient and scalable server-side applications, has unveiled its much-anticipated version 11. This release introduces a plethora of new features, performance enhancements, and critical updates designed to streamline development and bolster application performance. In this article, we'll delve into the most notable additions and changes in NestJS 11.

1. Enhanced Error Handling with IntrinsicException

NestJS 11 introduces the IntrinsicException class, providing developers with the ability to throw exceptions that bypass the framework's automatic logging mechanism. This feature is particularly beneficial when handling sensitive errors or scenarios where logging is unnecessary.

Example Usage:

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

@Injectable()
export class UserService {
  async findUser(id: string) {
    const user = await this.userRepository.findOne(id);
    if (!user) {
      throw new IntrinsicException('User not found'); // This won't be auto-logged
    }
    return user;
  }
}

By utilizing IntrinsicException, developers can prevent sensitive information from being logged, ensuring enhanced security and cleaner log outputs.

2. Advanced Caching with Updated CacheModule

The CacheModule has been revamped to integrate with cache-manager v6, which now leverages Keyv for a unified key-value storage interface. This update supports various storage backends, including Redis, MongoDB, and in-memory storage, offering greater flexibility in caching strategies.

Example Configuration:

import { CacheModule } from '@nestjs/cache-manager';
import * as redisStore from 'cache-manager-redis-store';

@Module({
  imports: [
    CacheModule.register({
      store: redisStore,
      host: 'localhost',
      port: 6379,
      ttl: 60, // Time-to-live in seconds
    }),
  ],
})
export class AppModule {}

Using the Cache:

import { Injectable, Cache } from '@nestjs/common';
import { InjectCache } from '@nestjs/cache-manager';

@Injectable()
export class UserService {
  constructor(@InjectCache() private readonly cacheManager: Cache) {}

  async getUser(id: string) {
    const cachedUser = await this.cacheManager.get(`user_${id}`);
    if (cachedUser) {
      return cachedUser;
    }
    const user = await this.userRepository.findOne(id);
    await this.cacheManager.set(`user_${id}`, user, 60); // Cache for 60 seconds
    return user;
  }
}

This enhancement ensures more efficient and flexible caching mechanisms, especially beneficial for distributed systems.

3. Improved Configuration Management with ConfigService

The ConfigService now allows developers to override process.env values using custom configuration factories. Additionally, the introduction of the skipProcessEnv option simplifies testing by bypassing environment variable loading when necessary.

Example Configuration:

import { ConfigModule, ConfigService } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({
      skipProcessEnv: true, // Skip loading process.env
      load: [() => ({ database: { host: 'localhost', port: 5432 } })],
    }),
  ],
})
export class AppModule {}

Using ConfigService:

@Injectable()
export class DatabaseService {
  constructor(private readonly configService: ConfigService) {}

  getDatabaseConfig() {
    return {
      host: this.configService.get<string>('database.host'),
      port: this.configService.get<number>('database.port'),
    };
  }
}

These updates provide greater flexibility in managing configuration values, particularly advantageous in testing and varied deployment environments.

4. JSON Logging with ConsoleLogger

NestJS 11 enhances the default ConsoleLogger by introducing built-in JSON logging support, facilitating seamless integration with log aggregation tools and improving log readability in structured formats.

Example Usage:

const app = await NestFactory.create(AppModule, {
  logger: new ConsoleLogger({
    json: true,
    colors: process.env.NODE_ENV === 'development', // Enable colors for local development
  }),
});

This configuration outputs logs in JSON format, ideal for containerized environments and centralized logging systems.

5. Advanced Microservices Control with unwrap()

The new unwrap() method for microservice transporters grants developers direct access to the underlying client instance, enabling advanced use cases such as inspecting connection details or performing low-level configurations.

Example Usage:

const serviceRef = app.connectMicroservice({
  transport: Transport.NATS,
  options: { servers: ['nats://localhost:4222'] },
});

const natsConnection = serviceRef.unwrap<NatsConnection>();
console.log(natsConnection.info); // Access NATS connection details

This feature provides developers with greater control over microservice communications and configurations.

6. Simplified Date Validation with ParseDatePipe

The introduction of ParseDatePipe streamlines date validation in requests, ensuring that incoming date values are properly formatted and reducing the need for repetitive validation logic.

Example Usage:

@Get()
async find(@Query('date', ParseDatePipe) date: Date) {
  return { date };
}

This pipe automatically validates and transforms date strings into Date objects, enhancing data integrity and simplifying controller logic.

7. Support for Express v5 and Fastify v5

NestJS 11 aligns with the latest versions of both Express and Fastify, ensuring compatibility and leveraging the improvements these platforms offer.

• Express v5: Introduces changes in route syntax, such as requiring named wildcards.

  Updated Syntax:

  @Get('users/*splat') // Named wildcard
  findAll() { ... }

• Fastify v5: Upgrades are seamless, with performance and stability enhancements.

Developers should review and update their route definitions to ensure compatibility with these new versions.

8. Optimized Application Startup

Dynamic module initialization has been optimized in NestJS 11, reducing startup times for large applications. Improvements in dependency injection and lazy loading mechanisms contribute to a more efficient bootstrapping process.

Key Enhancements:

• Faster Dependency Resolution: Reduces the time required to resolve and instantiate dependencies.

• Optimized Lazy Loading: Modules are loaded only when needed, improving startup performance.

• Refined Lifecycle Hooks: Enhancements in onModuleInit and onApplicationBootstrap ensure smoother execution of initialization logic.

These optimizations are especially beneficial for enterprise-scale applications, microservices, and serverless deployments where cold start times matter.

Conclusion

NestJS 11 brings a wealth of improvements, including enhanced error handling, advanced caching, improved configuration management, JSON logging, better microservices control, and optimized performance. These updates make NestJS even more powerful, flexible, and developer-friendly.

If you're using NestJS in production, consider upgrading to leverage these new capabilities. Stay tuned for future updates, as the NestJS team continues to refine and expand this incredible framework.

🚀 What are your thoughts on NestJS 11? Have you tried the new features yet? Share your experiences in the comments!