Implement Pipes in NestJS: Complete Guide with Examples and Benefits

 

How to Implement Pipes in NestJS: Complete Guide with Examples and Benefits

NestJS is a progressive Node.js framework that enables developers to build efficient and scalable server-side applications. One of its standout features is the concept of Pipes, which provides a robust mechanism for transforming and validating data in a structured and reusable way.

In this article, we will explore what Pipes are in NestJS, their benefits, and how to implement them with complete examples using both REST and GraphQL.

What Are Pipes in NestJS?

In NestJS, Pipes are classes that implement the PipeTransform interface. They are primarily used for:

1. Data Transformation: Transforming input data to the desired format.
2. Data Validation: Ensuring the data meets certain criteria before being processed further.

Pipes can be applied at different levels:

• Method Level: On specific handler parameters.
• Controller/Resolver Level: Across all methods within a controller or resolver.
• Global Level: For every route or resolver in the application.

Benefits of Using Pipes

1. Code Reusability: Pipes encapsulate transformation and validation logic, making it reusable across multiple parts of the application.
2. Separation of Concerns: Keeps the validation and transformation logic separate from the core business logic.
3. Improved Maintainability: Centralized validation logic is easier to maintain and update.
4. Error Handling: Automatically handles validation errors and returns meaningful responses.

Implementing Pipes in NestJS

Let’s go through a step-by-step process to implement and use Pipes in a NestJS application for both REST and GraphQL.

Step 1: Creating a Custom Pipe

Here’s an example of a custom pipe that validates and transforms a string to uppercase:

import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';
@Injectable()
export class UppercasePipe implements PipeTransform {
  transform(value: any) {
    if (typeof value !== 'string') {
      throw new BadRequestException('Value must be a string');
    }
    return value.toUpperCase();
  }
}

Step 2: Using the Custom Pipe in a REST API

1. Method Level:

import { Controller, Get, Query } from '@nestjs/common';
import { UppercasePipe } from './uppercase.pipe';
@Controller('example')
export class ExampleController {
  @Get()
  getExample(@Query('name', UppercasePipe) name: string) {
    return { message: `Hello, ${name}!` };
  }
}

1. Controller Level:

import { Controller, UsePipes, Get, Query } from '@nestjs/common';
import { UppercasePipe } from './uppercase.pipe';
@Controller('example')
@UsePipes(UppercasePipe)
export class ExampleController {
  @Get()
  getExample(@Query('name') name: string) {
    return { message: `Hello, ${name}!` };
  }
}

1. Global Level:

To apply a pipe globally, update the main bootstrap file:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { UppercasePipe } from './uppercase.pipe';
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new UppercasePipe());
  await app.listen(3000);
}
bootstrap();

Step 3: Using the Custom Pipe in a GraphQL Resolver

1. Method Level:

import { Resolver, Query, Args } from '@nestjs/graphql';
import { UppercasePipe } from './uppercase.pipe';
@Resolver()
export class ExampleResolver {
  @Query(() => String)
  getExample(@Args('name', { type: () => String }, UppercasePipe) name: string): string {
    return `Hello, ${name}!`;
  }
}

1. Resolver Level:

import { Resolver, Query, Args, UsePipes } from '@nestjs/graphql';
import { UppercasePipe } from './uppercase.pipe';
@Resolver()
@UsePipes(UppercasePipe)
export class ExampleResolver {
  @Query(() => String)
  getExample(@Args('name', { type: () => String }) name: string): string {
    return `Hello, ${name}!`;
  }
}

1. Global Level:

To apply a pipe globally, update the main bootstrap file:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { UppercasePipe } from './uppercase.pipe';
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new UppercasePipe());
  await app.listen(3000);
}
bootstrap();

Built-in Pipes in NestJS

NestJS provides several built-in pipes for common use cases:

1. ValidationPipe: Validates input data using class-validator.
2. ParseIntPipe: Transforms a string to an integer.
3. ParseBoolPipe: Transforms a string to a boolean.
4. DefaultValuePipe: Assigns a default value if none is provided.
5. ParseArrayPipe: Validates and transforms array inputs.

Example using ValidationPipe with REST:

import { Controller, Post, Body } from '@nestjs/common';
import { ValidationPipe } from '@nestjs/common';
class CreateUserDto {
  name: string;
  age: number;
}
@Controller('users')
export class UsersController {
  @Post()
  createUser(@Body(new ValidationPipe()) user: CreateUserDto) {
    return { message: 'User created', user };
  }
}

Example using ValidationPipe with GraphQL:

import { Resolver, Mutation, Args } from '@nestjs/graphql';
import { ValidationPipe } from '@nestjs/common';
class CreateUserDto {
  name: string;
  age: number;
}
@Resolver()
export class UsersResolver {
  @Mutation(() => String)
  createUser(@Args('input', new ValidationPipe()) user: CreateUserDto): string {
    return `User created: ${JSON.stringify(user)}`;
  }
}

Best Practices

1. Use DTOs with ValidationPipe: Define Data Transfer Objects (DTOs) for structured validation.
2. Combine Multiple Pipes: Use both built-in and custom pipes for complex scenarios.
3. Error Messages: Customize error messages to make them user-friendly.
4. Global Pipes: Use global pipes for application-wide validation policies.

Conclusion

Pipes in NestJS are powerful tools for transforming and validating data, whether in REST or GraphQL applications. By leveraging built-in and custom pipes, developers can build cleaner, more maintainable, and robust APIs. Whether you’re validating user input or transforming data formats, Pipes streamline the process, letting you focus on your core business logic.

Get started with Pipes today and elevate your NestJS development!

If you found this guide helpful, feel free to connect with me on LinkedIn for more insights on NestJS and backend development. Let’s keep learning together!

#NestJS #NodeJS #GraphQL #RESTAPI #BackendDevelopment #Pipes #WebDevelopment #JavaScript #TypeScript #ProgrammingTips #TechGuide #APIDevelopment #DataValidation #SoftwareEngineering #FullStackDevelopment #TechCommunity

Follow Me:

• GitHub
• YouTube
• My Portfolio
• Medium

Happy Learning 😊