NestJS Pipes : Create Pipe In NestJS In Hindi

If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.

NestJS में Pipes एक essential feature हैं जो आपको data transformation और validation करने में help करते हैं। Pipes request के incoming data को transform करते हैं या validate करते हैं, और अगर data incorrect या invalid हो, तो automatically errors throw करते हैं।

इस topic में हम detail में समझेंगे कि NestJS Pipes क्या होते हैं, कैसे काम करते हैं, कैसे इन्हे use करते हैं, और कैसे custom pipes बनाये जा सकते हैं।

What is Pipe ?

NestJS में pipes एक ऐसा mechanism हैं जो incoming data को process करते हैं , यह या तो data को transform करते हैं (e.g., string को number में convert करना) या validate करते हैं (e.g., check करना कि input valid है या नहीं).

अगर validation fail होती है, तो pipe automatically एक exception throw करता है।

In simpler terms -

• Pipes ऐसे components होते हैं जो request data को validate या transform करने का काम करते हैं।

• Transform : Data को एक format से दूसरे format में convert करना।

• Validate : Data को check करना कि वो correct और valid है या नहीं।

●●●

NestJS Built-in Pipes

NestJS में कुछ built-इन pipes होते हैं जो commonly used transformations और validations handle करते हैं। यह pipes आप directly use कर सकते हैं बिना custom pipes लिखने के।

1. NestJS ValidationPipe

• यह pipe request data को validate करता है, जैसे आपको ensure करना हो कि body या query params सही format में हैं ।

• Example : अगर आपको input में कोई number expect कर रहे हैं, तो यह check करेगा कि user ने सही number pass किया है या नहीं।

2. NestJS ParseIntPipe

• यह pipe string को integer में convert करता है।

• Example : अगर आपको route parameter में id number form में चाहिए, तो यह pipe string को integer में parse करेगा।

Copy
@Get(':id')
findOne(@Param('id', ParseIntPipe) id: number) {
  return `This action returns a user with id: ${id}`;
}

3. NestJS ParseBoolPipe

यह pipe input को boolean (true या false) value में convert करता है।

4. NestJs ParseUUIDPipe

यह pipe input को UUID (Universal Unique Identifier) format में validate करता है।

Copy
@Get(':uuid')
findByUUID(@Param('uuid', ParseUUIDPipe) uuid: string) {
  return `This action returns a user with UUID: ${uuid}`;
}

●●●

NestJS Pipe Example

Pipes को बनाने के लिए PipeTransform interface को implement करना पड़ता है, और @Injectable() decorator का use करना होता है।

चलिए एक basic transformation pipe बनाते हैं जो string को uppercase में convert करेगा।

Step 1 : Create UpperCase Pipe

File : src/pipes/uppercase.pipe.ts

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

@Injectable()
export class UpperCasePipe implements PipeTransform {
  transform(value: any) {
    if (typeof value === 'string') {
      return value.toUpperCase();
    }
    return value;
  }
}

इस pipe में transform() method, input value को uppercase में convert करता है अगर वो string हो।

●●●

NestJS Custom Pipe Example

अब चलिए एक custom validation pipe बनाते हैं जो check करेगा कि input number positive है या नहीं। अगर input negative होगा तो error throw करेंगे।

Step 2 : Create PositiveInt Pipe

File : src/pipes/positive-int.pipe.ts

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

@Injectable()
export class PositiveIntPipe implements PipeTransform {
  transform(value: any) {
    const val = parseInt(value, 10);
    if (isNaN(val) || val <= 0) {
      throw new BadRequestException('Input must be a positive integer');
    }
    return val;
  }
}

Explanation

• transform() method : यह method input को integer में convert करता है, और check करता है कि input positive integer है या नहीं।

• BadRequestException : अगर validation fail होती है, तो pipe BadRequestException throw करेगा, जो HTTP 400 response के साथ client को error message भेजता है।

●●●

NestJS Use Pipe in Controller

Pipes को controller methods के parameters के साथ use किया जाता है। आप इन्हे specific route parameters या request body के लिए apply कर सकते हैं।

Step 3 : Use Pipes in Controller

File : src/user/user.controller.ts

Copy
import { Controller, Get, Param } from '@nestjs/common';
import { PositiveIntPipe } from '../pipes/positive-int.pipe';

@Controller('users')
export class UserController {
  @Get(':id')
  findOne(@Param('id', PositiveIntPipe) id: number) {
    return `This action returns a user with the id: ${id}`;
  }
}

यहां PositiveIntPipe को @Param('id', PositiveIntPipe) के साथ apply किया गया है, जो check करेगा कि id एक positive integer है या नहीं।

●●●

NestJS Global Pipe

अगर आपको pipe को application के हर route पर apply करना है, तो आप global pipes का use कर सकते हैं। इस तरह का pipe हर incoming request के लिए automatically apply होगा।

Step 4 : Register Global Pipe

File : src/main.ts

Copy
import { ValidationPipe } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  
  // Global validation pipe
  app.useGlobalPipes(new ValidationPipe());
  
  await app.listen(3000);
}
bootstrap();

इस example में ValidationPipe को globally apply किया गया है, जो हर request के incoming data को validate करेगा।

●●●

NestJS Ways of Registering Pipe

Pipes को different levels पर register किया जा सकता है।

• Method Level : Specific controller method के लिए।

• Controller Level : Poore controller के सभी methods के लिए।

• Global Level : Application के हर route के लिए।

1. NestJS Pipe In Method

Copy
@Get(':id')
findOne(@Param('id', ParseIntPipe) id: number) {
  return `User with id: ${id}`;
}

2. NestJS Pipe In Controller

Copy
@Controller('users')
@UsePipes(new ValidationPipe())  // Poore controller ke liye pipe apply hoga
export class UserController {
  @Get(':id')
  findOne(@Param('id') id: number) {
    return `User with id: ${id}`;
  }
}

3. NestJS Global Pipe

Copy
app.useGlobalPipes(new ValidationPipe());  // Application ke har route ke liye pipe

●●●

NestJS Pipes Best Practices

• Use Built-in Pipes : NestJS के built-in pipes जैसे ValidationPipe और ParseIntPipe का use करें जहाँ possible हो। इनसे common validations easily handle हो जाती हैं। 

• Modular Pipes : Pipes को specific modules के लिए बनाएं। जैसे अगर आप UserModule में specific validation कर रहे हैं, तो वहां custom pipes बनाएं।

• Global Pipes for Validation : अगर आपको application-wide data validation चाहिए, तो ValidationPipe को globally apply करना best practice होती है।

• Throw Meaningful Errors : Pipes में errors throw करते वक्त meaningful messages return करें, ताकि user easily समझ सके कि input में क्या गलती हुई है।

●●●

NestJS Pipe Structure

Copy
src/
│
├── pipes/
│   ├── positive-int.pipe.ts       # Custom pipe for validating positive integers
│   ├── uppercase.pipe.ts          # Custom pipe for transforming strings to uppercase
│
├── user/
│   ├── user.controller.ts         # User controller
│   ├── user.module.ts             # User module
│
├── app.module.ts                  # Root module
├── main.ts                        # Global validation pipe register

●●●

Conclusion

NestJS में Pipes एक powerful feature हैं जो आपको data को validate और transform करने कि facility देते हैं। Pipes को आप incoming data को clean और secure बनाने के लिए use कर सकते हैं।

इनका सही implementation आपके application को robust और error-free बनाता है।

Key Points

• Pipes request data को transform और validate करते हैं।

• Built-इन Pipes जैसे ParseIntPipe और ValidationPipe का use करना easy और effective होता है।

• Custom pipes बनाए आप अपनी specific validation और transformation logic implement कर सकते हैं।