Custom pipes in NestJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a custom pipe class in NestJS.

NestJS

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

@Injectable()
export class ParseIntPipe implements [1] {
  transform(value: any) {
    return parseInt(value, 10);
  }
}

Drag options to blanks, or click blank then click option'

AController

BPipeTransform

CModule

DService

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Controller or @Module decorators instead of @Injectable.

Not implementing PipeTransform interface.

The custom pipe class must implement the PipeTransform interface to define the transform method.

2fill in blank

medium

Complete the code to throw an exception if the value is not a number in the custom pipe.

NestJS

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

@Injectable()
export class ParseIntPipe implements PipeTransform {
  transform(value: any) {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new [1]('Validation failed');
    }
    return val;
  }
}

Drag options to blanks, or click blank then click option'

ANotFoundException

BHttpException

CUnauthorizedException

DBadRequestException

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing exceptions unrelated to validation like NotFoundException.

Not throwing any exception on invalid input.

BadRequestException is used to indicate that the client sent invalid data.

3fill in blank

hard

Fix the error in the custom pipe to correctly implement the transform method signature.

NestJS

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

@Injectable()
export class ParseIntPipe implements PipeTransform {
  transform(value: any, [1]) {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new Error('Validation failed');
    }
    return val;
  }
}

Drag options to blanks, or click blank then click option'

Acontext: ExecutionContext

Bargs: any[]

Cmetadata: ArgumentMetadata

Drequest: Request

Attempts:

3 left

💡 Hint

Common Mistakes

Using ExecutionContext which is for guards and interceptors.

Omitting the second parameter or using wrong types.

The transform method receives the value and an ArgumentMetadata object describing the parameter.

4fill in blank

hard

Fill both blanks to apply the custom pipe to a controller route parameter.

NestJS

import { Controller, Get, Param } from '@nestjs/common';
import { ParseIntPipe } from './parse-int.pipe';

@Controller('items')
export class ItemsController {
  @Get(':id')
  findOne(@Param('[1]', [2]) id: number) {
    return `Item #${id}`;
  }
}

Drag options to blanks, or click blank then click option'

Aid

BParseIntPipe

Cbody

DValidationPipe

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong parameter name like 'body'.

Applying a different pipe than the custom one.

The route parameter name is 'id' and the custom pipe ParseIntPipe is applied to transform it.

5fill in blank

hard

Fill all three blanks to create a reusable custom pipe that validates a positive integer.

NestJS

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

@Injectable()
export class PositiveIntPipe implements PipeTransform {
  transform(value: any) {
    const val = parseInt([1], 10);
    if (isNaN(val) || val [2] 0) {
      throw new [3]('Value must be a positive integer');
    }
    return val;
  }
}

Drag options to blanks, or click blank then click option'

Avalue

B<=

CBadRequestException

Dvalue.toString()

Attempts:

3 left

💡 Hint

Common Mistakes

Parsing the raw value without converting to string.

Using wrong comparison operator.

Throwing generic Error instead of BadRequestException.

Convert value to string before parsing, check if val is less or equal to zero, and throw BadRequestException on failure.

Practice

1.

What is the main purpose of a custom pipe in NestJS?

easy

A. To transform or validate data before it reaches the route handler

B. To handle database connections automatically

C. To manage user sessions and cookies

D. To style the frontend components

Solution

1. Step 1: Understand the role of pipes in NestJS

   Pipes are used to transform or validate incoming data before it reaches the controller methods.

2. Step 2: Identify what custom pipes specifically do

   Custom pipes allow developers to create their own logic for data transformation or validation to ensure data safety and correctness.

3. Final Answer:

   To transform or validate data before it reaches the route handler -> Option A

4. Quick Check:

   Custom pipes = data validation/transformation [OK]

Hint: Pipes act on data before controller uses it [OK]

Common Mistakes:

• Confusing pipes with middleware
• Thinking pipes handle database or session logic
• Assuming pipes style frontend components

2.

Which of the following is the correct way to define a custom pipe class in NestJS?

export class MyPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    // logic here
  }
}

easy

A. export class MyPipe implements PipeTransform { transform(value: any) { } }

B. export class MyPipe implements PipeTransform { transform(value: any, metadata: ArgumentMetadata) { } }

C. export function MyPipe(value: any) { return value; }

D. export class MyPipe { transform(value: any, metadata: ArgumentMetadata) { } }

Solution

1. Step 1: Recall the PipeTransform interface signature

   The transform method must accept two parameters: value and metadata of type ArgumentMetadata.

2. Step 2: Check which option matches the correct method signature

   export class MyPipe implements PipeTransform { transform(value: any, metadata: ArgumentMetadata) { } } correctly implements the transform method with both parameters and the class implements PipeTransform.

3. Final Answer:

   export class MyPipe implements PipeTransform { transform(value: any, metadata: ArgumentMetadata) { } } -> Option B

4. Quick Check:

   transform(value, metadata) = correct signature [OK]

Hint: transform method needs value and metadata parameters [OK]

Common Mistakes:

• Omitting the metadata parameter
• Using a function instead of a class
• Not implementing PipeTransform interface

3.

Given this custom pipe code, what will be the output if the input value is "123"?

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

@Injectable()
export class ParseIntPipe implements PipeTransform {
  transform(value: any) {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new BadRequestException('Validation failed');
    }
    return val;
  }
}

Input: "123"

medium

A. Returns NaN

B. Throws BadRequestException

C. Returns string "123"

D. Returns number 123

Solution

1. Step 1: Understand parseInt behavior on string "123"

   parseInt("123", 10) converts the string "123" to the number 123.

2. Step 2: Check the validation condition

   Since 123 is a valid number, isNaN(val) is false, so no exception is thrown and the number 123 is returned.

3. Final Answer:

   Returns number 123 -> Option D

4. Quick Check:

   parseInt("123") = 123 [OK]

Hint: parseInt("123") returns number 123, no error [OK]

Common Mistakes:

• Thinking it returns string instead of number
• Assuming it throws error for numeric strings
• Confusing NaN with valid number

4.

Identify the error in this custom pipe code:

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

@Injectable()
export class UppercasePipe implements PipeTransform {
  transform(value: string) {
    return value.toUpperCase;
  }
}

medium

A. Missing @Injectable decorator

B. transform method missing return type

C. toUpperCase is used without parentheses

D. PipeTransform interface not implemented

Solution

1. Step 1: Check the transform method implementation

   The method returns value.toUpperCase without parentheses, which is a reference to the function, not the result.

2. Step 2: Identify correct usage of toUpperCase

   toUpperCase is a method and must be called with parentheses: value.toUpperCase()

3. Final Answer:

   toUpperCase is used without parentheses -> Option C

4. Quick Check:

   Method calls need () to execute [OK]

Hint: Remember to call string methods with () [OK]

Common Mistakes:

• Forgetting parentheses on method calls
• Assuming decorators are missing when present
• Ignoring interface implementation

5.

You want to create a custom pipe that trims whitespace and converts input to lowercase. Which of these implementations correctly achieves this?

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

@Injectable()
export class NormalizePipe implements PipeTransform {
  transform(value: any) {
    // Which option is correct?
  }
}

hard

A. return value.trim().toLowerCase();

B. return value.replace(/\s/g, '').toLowerCase();

C. return value.trim.toLowerCase();

D. return value.toLowerCase.trim();

Solution

1. Step 1: Understand method chaining order

   trim() removes whitespace from start and end, then toLowerCase() converts to lowercase. The order matters to avoid errors.

2. Step 2: Check method call syntax

   Both trim() and toLowerCase() are methods and must be called with parentheses. return value.trim().toLowerCase(); correctly calls them in order: value.trim().toLowerCase()

3. Final Answer:

   return value.trim().toLowerCase(); -> Option A

4. Quick Check:

   Correct method chaining with () = return value.trim().toLowerCase(); [OK]

Hint: Call trim() before toLowerCase(), both with () [OK]

Common Mistakes:

• Calling methods without parentheses
• Wrong method chaining order
• Using properties instead of methods