File validation pipe in NestJS - Step-by-Step Execution

Concept Flow - File validation pipe

File Upload Request

↓

Pipe Receives File

↓

Validate File Type?

No→Throw Error: Invalid Type

Yes↓

Validate File Size?

No→Throw Error: File Too Large

Yes↓

Pass Valid File to Controller

↓

Controller Processes File

The file validation pipe checks the uploaded file's type and size before allowing it to reach the controller.

Execution Sample

NestJS

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

@Injectable()
export class FileValidationPipe implements PipeTransform {
  transform(file: Express.Multer.File) {
    if (!file) throw new BadRequestException('No file uploaded');
    if (!['image/png', 'image/jpeg'].includes(file.mimetype)) {
      throw new BadRequestException('Invalid file type');
    }
    if (file.size > 1024 * 1024) {
      throw new BadRequestException('File too large');
    }
    return file;
  }
}

This pipe checks if a file exists, then validates its type and size, throwing errors if invalid.

Execution Table

Step	Action	Input File	Check	Result	Next Step
1	Receive file	{mimetype: 'image/png', size: 500000}	File exists?	Yes	Validate type
2	Validate type	image/png	Is type in ['image/png', 'image/jpeg']?	Yes	Validate size
3	Validate size	500000 bytes	Is size <= 1MB?	Yes	Return file
4	Return	Valid file	N/A	File passed validation	Controller receives file
5	Receive file	null	File exists?	No	Throw error: No file uploaded
6	Receive file	{mimetype: 'application/pdf', size: 500000}	File exists?	Yes	Validate type
7	Validate type	application/pdf	Is type in ['image/png', 'image/jpeg']?	No	Throw error: Invalid file type
8	Receive file	{mimetype: 'image/jpeg', size: 2000000}	File exists?	Yes	Validate type
9	Validate type	image/jpeg	Is type in ['image/png', 'image/jpeg']?	Yes	Validate size
10	Validate size	2000000 bytes	Is size <= 1MB?	No	Throw error: File too large

💡 Execution stops when file fails validation or passes all checks successfully.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
file	undefined	{mimetype: 'image/png', size: 500000}	{mimetype: 'image/png', size: 500000}	{mimetype: 'image/png', size: 500000}	Returned valid file
file	undefined	null	null	null	Error thrown: No file uploaded
file	undefined	{mimetype: 'application/pdf', size: 500000}	{mimetype: 'application/pdf', size: 500000}	N/A	Error thrown: Invalid file type
file	undefined	{mimetype: 'image/jpeg', size: 2000000}	{mimetype: 'image/jpeg', size: 2000000}	{mimetype: 'image/jpeg', size: 2000000}	Error thrown: File too large

Key Moments - 3 Insights

Why does the pipe throw an error if the file is null?

Because the pipe first checks if a file exists (Step 1 in execution_table). If the file is null or undefined, it immediately throws a 'No file uploaded' error to prevent further processing.

What happens if the file type is not in the allowed list?

At Step 7 in execution_table, if the file mimetype is not 'image/png' or 'image/jpeg', the pipe throws an 'Invalid file type' error and stops execution.

How does the pipe handle files larger than 1MB?

At Step 10, the pipe checks the file size. If it exceeds 1MB (1024*1024 bytes), it throws a 'File too large' error, preventing the file from reaching the controller.

Visual Quiz - 3 Questions

Look at the execution table, what is the result at Step 3 when the file size is 500000 bytes?

A File size is valid, proceed to return file

B File size is too large, throw error

C File type is invalid, throw error

D No file uploaded error

💡 Hint

Check Step 3 row in execution_table for file size validation result.

At which step does the pipe throw an error for an unsupported file type?

A Step 10

B Step 2

C Step 7

D Step 5

💡 Hint

Look for the step where file mimetype is checked against allowed types and error is thrown.

If the file is missing, what will the variable 'file' be at Step 1 and what happens next?

A 'file' is valid, pipe continues validation

B 'file' is null, pipe throws 'No file uploaded' error

C 'file' is undefined, pipe returns file

D 'file' is null, pipe accepts file

💡 Hint

Refer to variable_tracker and execution_table Step 5 for file null check.

Concept Snapshot

File Validation Pipe in NestJS:
- Implements PipeTransform interface
- Checks if file exists
- Validates file mimetype against allowed list
- Validates file size limit
- Throws BadRequestException on failure
- Passes valid file to controller
- Ensures safe file uploads

Full Transcript

This visual execution trace shows how a NestJS file validation pipe works step-by-step. When a file upload request arrives, the pipe first checks if a file is present. If not, it throws a 'No file uploaded' error. If a file exists, it checks the file type against allowed types like 'image/png' and 'image/jpeg'. If the type is invalid, it throws an error. Next, it checks the file size to ensure it does not exceed 1MB. If the file is too large, it throws an error. If all checks pass, the pipe returns the valid file to the controller for further processing. The variable tracker shows how the file variable changes or triggers errors at each step. Key moments clarify common confusions about missing files, invalid types, and size limits. The quiz questions help reinforce understanding by referencing specific steps and variable states in the execution table.

Practice

1. What is the main purpose of a FileValidationPipe in NestJS?

easy

A. To upload files to a cloud storage service

B. To convert files into JSON format automatically

C. To check uploaded files for type, size, and presence before processing

D. To compress files before saving them

Solution

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

   Validation pipes are used to check and validate incoming data before it reaches the controller logic.

2. Step 2: Apply this to file uploads

   A FileValidationPipe specifically checks uploaded files for correct type, size, and presence to prevent bad data.

3. Final Answer:

   To check uploaded files for type, size, and presence before processing -> Option C

4. Quick Check:

   File validation = check file properties [OK]

Hint: Validation pipes check data early to keep apps safe [OK]

Common Mistakes:

• Thinking pipes upload or transform files
• Confusing validation with file storage
• Assuming pipes compress files automatically

2. Which of the following is the correct way to apply a file validation pipe to a file upload in a NestJS controller?

easy

A. @UsePipes(new FileValidationPipe()) uploadFile(@UploadedFile() file: Express.Multer.File) {}

B. @UseGuards(new FileValidationPipe()) uploadFile(@UploadedFile() file: Express.Multer.File) {}

C. @UseFilters(new FileValidationPipe()) uploadFile(@UploadedFile() file: Express.Multer.File) {}

D. @UseInterceptors(new FileValidationPipe()) uploadFile(@UploadedFile() file: Express.Multer.File) {}

Solution

1. Step 1: Identify the correct decorator for validation pipes

   In NestJS, validation pipes are applied using the @UsePipes() decorator.

2. Step 2: Match the usage with file upload

   The FileValidationPipe is a pipe, so it must be passed inside @UsePipes() to validate the uploaded file.

3. Final Answer:

   @UsePipes(new FileValidationPipe()) uploadFile(@UploadedFile() file: Express.Multer.File) {} -> Option A

4. Quick Check:

   Validation pipe = @UsePipes() [OK]

Hint: Use @UsePipes() for validation pipes, not guards or filters [OK]

Common Mistakes:

• Using @UseGuards or @UseFilters instead of @UsePipes
• Applying pipes without instantiating them
• Confusing interceptors with pipes

3. Given this pipe code snippet, what will happen if a user uploads a file larger than 1MB?

export class FileValidationPipe implements PipeTransform {
  transform(file: Express.Multer.File) {
    if (!file) throw new BadRequestException('File is required');
    if (file.size > 1_000_000) throw new BadRequestException('File too large');
    return file;
  }
}

medium

A. The pipe ignores the size and processes the file

B. The pipe accepts the file and returns it

C. The pipe throws a NotFoundException

D. The pipe throws a BadRequestException with message 'File too large'

Solution

1. Step 1: Analyze the size check in the transform method

   The pipe checks if file.size is greater than 1,000,000 bytes (1MB).

2. Step 2: Understand the exception thrown on size violation

   If the file is too large, it throws BadRequestException('File too large'), stopping the request.

3. Final Answer:

   The pipe throws a BadRequestException with message 'File too large' -> Option D

4. Quick Check:

   File size > 1MB = BadRequestException [OK]

Hint: Check exception messages in transform() for validation errors [OK]

Common Mistakes:

• Assuming the pipe accepts large files
• Confusing BadRequestException with NotFoundException
• Ignoring the file presence check

4. Identify the error in this file validation pipe code:

export class FileValidationPipe implements PipeTransform {
  transform(file: Express.Multer.File) {
    if (!file) throw new BadRequestException('File is required');
    if (file.mimetype !== 'image/png' || file.mimetype !== 'image/jpeg') {
      throw new BadRequestException('Invalid file type');
    }
    return file;
  }
}

medium

A. The mimetype check always throws because of incorrect logical operator

B. The file presence check is missing

C. The pipe does not return the file

D. The exception type is incorrect

Solution

1. Step 1: Examine the mimetype condition

   The condition uses || (OR) between two checks: file.mimetype !== 'image/png' OR file.mimetype !== 'image/jpeg'.

2. Step 2: Understand why this always triggers

   Because a file cannot be both 'image/png' and 'image/jpeg' at the same time, one of these will always be true, causing the exception every time.

3. Final Answer:

   The mimetype check always throws because of incorrect logical operator -> Option A

4. Quick Check:

   Use AND (&&) to check mimetype correctly [OK]

Hint: Use && to check if mimetype is neither png nor jpeg [OK]

Common Mistakes:

• Using || instead of && in mimetype checks
• Forgetting to return the file after validation
• Throwing wrong exception types

5. You want to create a file validation pipe that only accepts PDF files smaller than 2MB and throws a clear error if validation fails. Which of the following code snippets correctly implements this?

hard

A. export class PdfValidationPipe implements PipeTransform {
transform(file: Express.Multer.File) {
if (!file) throw new BadRequestException('File is required');
if (file.mimetype === 'application/pdf') throw new BadRequestException('Only PDFs allowed');
if (file.size > 2_000_000) throw new BadRequestException('File too large');
return file;
}
}

B. export class PdfValidationPipe implements PipeTransform {
transform(file: Express.Multer.File) {
if (!file) throw new BadRequestException('File is required');
if (file.mimetype !== 'application/pdf') throw new BadRequestException('Only PDFs allowed');
if (file.size >= 2_000_000) throw new BadRequestException('File too large');
return file;
}
}

C. export class PdfValidationPipe implements PipeTransform {
transform(file: Express.Multer.File) {
if (!file) throw new BadRequestException('File is required');
if (file.mimetype !== 'application/pdf' && file.size > 2_000_000) throw new BadRequestException('Invalid file');
return file;
}
}

D. export class PdfValidationPipe implements PipeTransform {
transform(file: Express.Multer.File) {
if (!file) throw new BadRequestException('File is required');
if (file.mimetype !== 'application/pdf' || file.size > 2_000_000) throw new BadRequestException('Invalid file');
return file;
}
}

Solution

1. Step 1: Verify correct logic for presence and mimetype

   Check if (!file) throw, then if (file.mimetype !== 'application/pdf') throw 'Only PDFs allowed'. Uses !== to reject non-PDFs.

2. Step 2: Separate size check for smaller than 2MB

   if (file.size >= 2_000_000) throw 'File too large'. Uses >= to reject 2MB or larger.

3. Step 3: Eliminate distractors

   B throws if PDF; C's && accepts non-PDF if small; D's > accepts exactly 2MB.

4. Final Answer:

   export class PdfValidationPipe implements PipeTransform { transform(file: Express.Multer.File) { if (!file) throw new BadRequestException('File is required'); if (file.mimetype !== 'application/pdf') throw new BadRequestException('Only PDFs allowed'); if (file.size >= 2_000_000) throw new BadRequestException('File too large'); return file; } } -> Option B

5. Quick Check:

   !== mimetype, >= size, separate ifs [OK]

Hint: Check each condition separately with !== and clear exceptions [OK]

Common Mistakes:

• Using === instead of !== for mimetype check
• Combining conditions incorrectly with && or ||
• Not throwing specific error messages