File validation pipe in NestJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a File Validation Pipe in NestJS?

A File Validation Pipe in NestJS is a special class that checks if uploaded files meet certain rules before the app processes them. It helps keep files safe and correct.

beginner

How do you use a File Validation Pipe in a NestJS controller?

You add the pipe to the file upload handler method using the @UsePipes() decorator or directly in the @UploadedFile() decorator to check the file before saving or processing it.

beginner

Which common file properties can a File Validation Pipe check?

It can check file size, file type (like images only), and sometimes file name or content to make sure the file is safe and fits the app's needs.

intermediate

What happens if a file does not pass the validation in a NestJS File Validation Pipe?

The pipe throws an error that stops the request. The user gets a clear message about why the file was rejected, like 'File too large' or 'Invalid file type'.

intermediate

Why is it important to validate files on the server side with a pipe?

Because client checks can be bypassed, server-side validation ensures only safe and expected files are accepted, protecting the app from bad files or attacks.

What is the main role of a File Validation Pipe in NestJS?

A To check uploaded files before processing

B To store files on the server

C To send files to the client

D To rename files automatically

A File Validation Pipe checks files to ensure they meet rules before the app processes them.

Which decorator is commonly used to apply a File Validation Pipe to a file upload method?

A @Post()

B @UseGuards()

C @Get()

D @UsePipes()

The @UsePipes() decorator applies validation pipes like the File Validation Pipe.

What happens if a file fails validation in a NestJS File Validation Pipe?

A An error is thrown and request stops

B The request continues without the file

C The file is saved anyway

D The file is renamed automatically

The pipe throws an error to stop the request and inform the user.

Which file property is NOT typically checked by a File Validation Pipe?

A File size

B File type

C File color

D File name

File color is not a property checked by validation pipes.

Why should file validation happen on the server side?

A Because files are only stored on the server

B Because client-side checks can be bypassed

C Because servers are faster

D Because clients cannot upload files

Server-side validation protects the app from unsafe files even if client checks fail.

Explain how a File Validation Pipe works in NestJS and why it is useful.

Think about what happens before the file is saved or processed.

Describe how to apply a File Validation Pipe to a file upload endpoint in NestJS.

Consider how NestJS pipes are used in controllers.

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