Why pipes transform and validate input in NestJS - Visual Breakdown

Concept Flow - Why pipes transform and validate input

Request Received

↓

Input Data

↓

Pipe: Validate Input

↓

Pipe: Transform Input

↓

Controller Receives Clean Data

↓

Process Request

Input data flows through pipes that first check if data is valid, then transform it before the controller uses it.

Execution Sample

NestJS

async function handleRequest(input) {
  const validInput = validate(input);
  if (!validInput) throw new Error('Invalid input');
  const transformed = transform(input);
  return process(transformed);
}

This code validates input, throws error if invalid, transforms valid input, then processes it.

Execution Table

Step	Action	Input	Validation Result	Transformation Result	Next Step
1	Receive input	{ age: '25' }	Not checked yet	Not transformed yet	Validate input
2	Validate input	{ age: '25' }	Valid (age is string but numeric)	Not transformed yet	Transform input
3	Transform input	{ age: '25' }	Valid	{ age: 25 } (string to number)	Send to controller
4	Controller receives	{ age: 25 }	Valid	{ age: 25 }	Process request
5	Process request	{ age: 25 }	Valid	{ age: 25 }	Request completed
6	Receive input	{ age: 'abc' }	Not checked yet	Not transformed yet	Validate input
7	Validate input	{ age: 'abc' }	Invalid (age not numeric)	Not transformed	Throw error
8	Throw error	Error: Invalid input	-	-	Request stopped

💡 Execution stops when validation fails or after processing valid input.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
input	{ age: '25' }	{ age: '25' }	{ age: '25' }	{ age: 25 }	{ age: 25 }
validationResult	Not checked	Valid	Valid	Valid	Valid
transformedInput	Not transformed	Not transformed	{ age: 25 }	{ age: 25 }	{ age: 25 }
error	null	null	null	null	null

Key Moments - 3 Insights

Why do pipes validate input before transforming it?

Validation ensures the data is correct and safe before any changes. See execution_table step 2 where invalid input stops the process before transformation.

What happens if input is invalid during validation?

The pipe throws an error and stops further processing, as shown in execution_table step 7 and 8.

Why transform input after validation?

Transformation converts input into the format the controller expects, like string to number in step 3, so the controller works with clean data.

Visual Quiz - 3 Questions

Look at the execution_table, what is the transformation result at step 3?

A Error: Invalid input

B { age: 25 } (string to number)

C { age: '25' } (unchanged)

D Not transformed yet

💡 Hint

Check the 'Transformation Result' column at step 3 in execution_table.

At which step does the process stop for invalid input?

A Step 7

B Step 5

C Step 3

D Step 2

💡 Hint

Look for 'Throw error' action in execution_table.

If input was already a number, how would the transformation step change?

A Validation would fail

B Transformation would convert number to string

C Transformation would be skipped or keep input as is

D Controller would reject input

💡 Hint

Refer to variable_tracker for how transformedInput changes after step 3.

Concept Snapshot

Pipes in NestJS first validate input to ensure it is correct.
If invalid, they stop processing and throw an error.
If valid, pipes transform input into the needed format.
This clean data is then passed to controllers.
This keeps app safe and data consistent.

Full Transcript

When a request comes in, NestJS pipes first check if the input data is valid. If the data is invalid, the pipe throws an error and stops the request. If the data is valid, the pipe transforms the input, for example changing strings to numbers. Then the controller receives this clean, transformed data to process the request. This flow ensures the app only works with safe and correct data.