File validation pipe in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a file larger than the allowed size is uploaded?

Consider a NestJS file validation pipe that limits file size to 1MB. What is the behavior when a user uploads a file of 2MB?

NestJS

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

@Injectable()
export class FileSizeValidationPipe implements PipeTransform {
  transform(file: Express.Multer.File) {
    const maxSize = 1 * 1024 * 1024; // 1MB
    if (file.size > maxSize) {
      throw new BadRequestException('File size exceeds limit');
    }
    return file;
  }
}

A The pipe throws a BadRequestException with message 'File size exceeds limit'.

B The pipe returns null and the upload is ignored.

C The pipe silently accepts the file and returns it without error.

D The pipe logs a warning but allows the file to pass through.

💡 Hint

Think about what happens when the file size condition fails inside the pipe.

The pipe checks the file size and throws a BadRequestException if the file is too large, stopping the request with an error.

📝 Syntax

intermediate

Identify the syntax error in this file validation pipe code

Which option contains a syntax error preventing the file validation pipe from compiling?

NestJS

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

@Injectable()
export class FileTypeValidationPipe implements PipeTransform {
  transform(file: Express.Multer.File) {
    const allowedTypes = ['image/png', 'image/jpeg'];
    if (!allowedTypes.includes(file.mimetype)) {
      throw new BadRequestException('Invalid file type');
    }
    return file;
  }
}

A if (!allowedTypes.includes(file.mimetype)) { throw new BadRequestException('Invalid file type'); }

B if (!allowedTypes.includes(file.mimetype)) throw new BadRequestException('Invalid file type');

C if (!allowedTypes.includes file.mimetype) { throw new BadRequestException('Invalid file type'); }

D if (!allowedTypes.includes(file.mimetype)) { throw new BadRequestException('Invalid file type'); } else return file;

💡 Hint

Check the syntax of the includes method call.

Option C is missing parentheses around the argument to includes, causing a syntax error.

❓ state_output

advanced

What is the output when the file validation pipe returns the file object?

Given a file validation pipe that returns the file object after validation, what will be the value passed to the controller handler?

NestJS

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

@Injectable()
export class FileValidationPipe implements PipeTransform {
  transform(file: Express.Multer.File) {
    // Assume validation passed
    return file;
  }
}

// Controller handler example
async uploadFile(@UploadedFile(new FileValidationPipe()) file: Express.Multer.File) {
  return { filename: file.originalname, size: file.size };
}

A undefined

B { filename: 'uploaded_file.png', size: 2048 } // file info object

C An error is thrown because the pipe does not return a value

D null

💡 Hint

The pipe returns the file object, so the controller receives it.

The pipe returns the validated file object, so the controller gets the file with its properties.

🔧 Debug

advanced

Why does this file validation pipe not catch invalid file types?

This pipe is intended to reject files not of type 'image/png' or 'image/jpeg', but it lets invalid files pass. Why?

NestJS

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

@Injectable()
export class FileTypeValidationPipe implements PipeTransform {
  transform(file: Express.Multer.File) {
    const allowedTypes = ['image/png', 'image/jpeg'];
    if (allowedTypes.indexOf(file.mimetype)) {
      return file;
    }
    throw new BadRequestException('Invalid file type');
  }
}

A The file.mimetype property is undefined, so the check fails silently.

B The allowedTypes array is empty, so no types are allowed.

C The pipe does not throw any error because transform is not called.

D indexOf returns -1 for missing items, which is truthy, so the condition is wrong.

💡 Hint

Check how indexOf behaves when the item is not found.

indexOf returns -1 when the item is not found, which is truthy in JavaScript, so the if condition incorrectly passes for invalid types.

🧠 Conceptual

expert

What is the main advantage of using a file validation pipe in NestJS?

Why should you use a dedicated file validation pipe instead of validating files directly inside controller methods?

A It centralizes validation logic, making code cleaner and reusable across multiple routes.

B It automatically compresses files before saving them.

C It prevents the need to import Multer in the controller.

D It allows files to be uploaded without any size or type restrictions.

💡 Hint

Think about code organization and reuse.

Using a pipe keeps validation separate from business logic, making the code easier to maintain and reuse.

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