Request validation in Node.js - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is request validation in Node.js?

Request validation is the process of checking incoming data from users or clients to make sure it is correct, safe, and complete before using it in your application.

beginner

Why is request validation important?

It helps prevent errors, security problems like injection attacks, and ensures your app works as expected by only accepting valid data.

beginner

Name a popular Node.js library used for request validation.

Joi is a popular library that helps define rules for data and check if incoming requests follow those rules.

intermediate

How does middleware help with request validation in Express.js?

Middleware runs before your main code and can check the request data. If data is invalid, it can stop the request and send an error response.

intermediate

What is a common pattern to handle validation errors in Node.js apps?

After validating data, if errors exist, return a response with status 400 and a message explaining what is wrong, so the client can fix it.

What does request validation check in Node.js apps?

A Database connection speed

B Server hardware status

C Incoming data correctness and safety

D User interface design

Request validation checks if the data sent by users is correct and safe before using it.

Which Node.js library is commonly used for schema-based validation?

A Express

B Joi

C React

D Lodash

Joi helps define and check data rules for validation.

In Express.js, where is validation logic usually placed?

A In middleware functions

B In the database

C In CSS files

D In HTML templates

Middleware runs before route handlers and is ideal for validation.

What HTTP status code is commonly returned when validation fails?

A 400

B 200

C 404

D 500

Status 400 means bad request, used when input data is invalid.

What should you do if request data is invalid?

A Restart the server

B Ignore the error

C Process it anyway

D Send an error response explaining the problem

Sending an error response helps the client fix the data.

Explain how you would add request validation to an Express.js route using middleware.

Think about how middleware runs before your route handler.

Describe why request validation improves security and reliability in Node.js applications.

Consider what could happen if invalid data is used unchecked.

Practice

1. What is the main purpose of request validation in a Node.js app?

easy

A. To store data in the database

B. To speed up the server response time

C. To check incoming data before using it

D. To create new routes automatically

Solution

1. Step 1: Understand request validation

   Request validation means checking the data sent by users before the app uses it.

2. Step 2: Identify the main goal

   The goal is to ensure data is safe and correct to avoid errors or security issues.

3. Final Answer:

   To check incoming data before using it -> Option C

4. Quick Check:

   Request validation = check data first [OK]

Hint: Validation means checking data before use [OK]

Common Mistakes:

• Thinking validation speeds up server
• Confusing validation with data storage
• Assuming validation creates routes

2. Which code snippet correctly uses express-validator to check if 'email' is valid?

easy

A. validateEmail('email').isValid()

B. validate('email').isEmail()

C. checkEmail('email').validate()

D. check('email').isEmail()

Solution

1. Step 1: Recall express-validator syntax

   express-validator uses check('fieldName').validationMethod() to validate fields.

2. Step 2: Match correct method for email

   The method is isEmail() to check if the input is a valid email.

3. Final Answer:

   check('email').isEmail() -> Option D

4. Quick Check:

   express-validator uses check() + isEmail() [OK]

Hint: Use check('field').isEmail() for email validation [OK]

Common Mistakes:

• Using validate() instead of check()
• Wrong method names like validateEmail()
• Mixing method order or names

3. Given this code, what will be the output if the request body has { email: 'not-an-email' }?

app.post('/signup', [
  check('email').isEmail(),
  (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    res.send('Success');
  }
]);

medium

A. Response with status 400 and error details

B. Response with 'Success' message

C. Server crashes with an error

D. Response with status 200 and empty body

Solution

1. Step 1: Check validation rule

   The rule check('email').isEmail() requires a valid email format.

2. Step 2: Analyze input and error handling

   The input 'not-an-email' fails isEmail(), so errors.isEmpty() is false, triggering status 400 with error details.

3. Final Answer:

   Response with status 400 and error details -> Option A

4. Quick Check:

   Invalid email triggers 400 error [OK]

Hint: Invalid input triggers 400 error with details [OK]

Common Mistakes:

• Assuming success response on invalid input
• Expecting server crash on validation fail
• Ignoring error handling logic

4. Identify the error in this validation middleware:

app.post('/login', [
  check('password').isLength({ min: 6 }),
  (req, res) => {
    const errors = validationResult;
    if (!errors.isEmpty()) {
      return res.status(422).json({ errors: errors.array() });
    }
    res.send('Logged in');
  }
]);

medium

A. validationResult is not called with req, so errors is not an object with isEmpty()

B. isLength should be isMinLength for password check

C. Missing next() call to continue middleware chain

D. Response status 422 is invalid for validation errors

Solution

1. Step 1: Check usage of validationResult

   validationResult must be called as validationResult(req) to get errors from the request.

2. Step 2: Identify the mistake in code

   The code assigns errors = validationResult without calling it, so errors is not an object with isEmpty().

3. Final Answer:

   validationResult is not called with req, so errors is not an object with isEmpty() -> Option A

4. Quick Check:

   Call validationResult(req) to get errors [OK]

Hint: Always call validationResult(req) to get errors [OK]

Common Mistakes:

• Forgetting to call validationResult as a function
• Using wrong validation method names
• Confusing middleware flow with next()

5. You want to validate a request body with fields 'username' (required, min 3 chars) and 'age' (optional, must be a number if present). Which express-validator setup is correct?

hard

A. [check('username').optional().isLength({ min: 3 }), check('age').isNumeric()]

B. [check('username').isLength({ min: 3 }).notEmpty(), check('age').optional().isNumeric()]

C. [check('username').isLength({ min: 3 }), check('age').notEmpty().isNumeric()]

D. [check('username').notEmpty(), check('age').optional().isString()]

Solution

1. Step 1: Validate 'username' requirements

   Username is required and must have at least 3 characters, so use notEmpty() and isLength({ min: 3 }).

2. Step 2: Validate 'age' requirements

   Age is optional but if present must be numeric, so use optional() and isNumeric().

3. Final Answer:

   [check('username').isLength({ min: 3 }).notEmpty(), check('age').optional().isNumeric()] -> Option B

4. Quick Check:

   Required username + optional numeric age = [check('username').isLength({ min: 3 }).notEmpty(), check('age').optional().isNumeric()] [OK]

Hint: Use optional() for optional fields, notEmpty() for required [OK]

Common Mistakes:

• Marking required fields as optional
• Not chaining optional() before other checks
• Using wrong validators like isString() for numbers