Input validation and sanitization in Node.js

Introduction

Input validation and sanitization help keep your app safe and working right by checking and cleaning user data before using it.

When users fill out forms on your website or app

When receiving data from external sources like APIs

Before saving user input to a database

When processing data that affects app behavior or security

Syntax

Node.js

import { body, validationResult } from 'express-validator';

app.post('/submit', [
  body('email').isEmail().normalizeEmail(),
  body('age').isInt({ min: 0 })
], (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }
  // Use sanitized and validated data here
  res.send('Data is valid and safe!');
});

Use express-validator middleware to validate and sanitize inputs in Node.js apps.

Always check validationResult to handle errors before using data.

Examples

Removes extra spaces and escapes harmful characters from a username input.

Node.js

body('username').trim().escape()

Checks if the input is a valid email and cleans it to a standard format.

Node.js

body('email').isEmail().normalizeEmail()

Validates that age is a whole number between 0 and 120.

Node.js

body('age').isInt({ min: 0, max: 120 })

Sample Program

This Node.js app uses Express and express-validator to check and clean user input for username, email, and age. If input is bad, it sends errors. If good, it welcomes the user with their cleaned data.

Node.js

import express from 'express';
import { body, validationResult } from 'express-validator';

const app = express();
app.use(express.json());

app.post('/register', [
  body('username').trim().escape(),
  body('email').isEmail().normalizeEmail(),
  body('age').isInt({ min: 0, max: 120 })
], (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }
  res.send(`Welcome, ${req.body.username}! Your email is ${req.body.email} and age is ${req.body.age}.`);
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

Important Notes

Always validate and sanitize inputs to avoid security risks like injection attacks.

Use libraries like express-validator to simplify input checks.

Test your validation by sending different inputs using tools like Postman or browser DevTools.

Summary

Input validation checks if data is correct and safe.

Sanitization cleans data to remove harmful parts.

Use middleware like express-validator in Node.js for easy validation and sanitization.

Practice

1. What is the main purpose of input validation in a Node.js application?

easy

A. To check if the input data is correct and safe before processing

B. To store user data in the database

C. To format the output data for display

D. To speed up the server response time

Solution

1. Step 1: Understand input validation

   Input validation ensures that the data received from users meets expected rules and is safe to use.

2. Step 2: Identify the purpose in Node.js

   In Node.js, input validation prevents bad or harmful data from causing errors or security issues.

3. Final Answer:

   To check if the input data is correct and safe before processing -> Option A

4. Quick Check:

   Input validation = check data safety [OK]

Hint: Validation means checking data correctness and safety [OK]

Common Mistakes:

• Confusing validation with data storage
• Thinking validation formats output
• Assuming validation improves speed

2. Which of the following is the correct way to import the express-validator middleware in a Node.js file using ES modules?

easy

A. const { check } = require('express-validator');

B. import check from 'express-validator';

C. const check = require('express-validator/check');

D. import { check } from 'express-validator';

Solution

1. Step 1: Identify modern import syntax

   Node.js with ES modules uses import { check } from 'express-validator'; to import named exports.

2. Step 2: Check other options

   const { check } = require('express-validator'); uses CommonJS require but destructuring is possible only if CommonJS is used; import check from 'express-validator'; imports default which express-validator does not export; const check = require('express-validator/check'); uses a wrong path.

3. Final Answer:

   import { check } from 'express-validator'; -> Option D

4. Quick Check:

   Use ES module import for express-validator [OK]

Hint: Use ES module import syntax with curly braces for named exports [OK]

Common Mistakes:

• Using require instead of import in ES modules
• Importing default instead of named export
• Using incorrect module paths

3. Consider this Node.js code snippet using express-validator:

app.post('/submit', [
  check('email').isEmail(),
  check('age').isInt({ min: 18 })
], (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }
  res.send('Data is valid');
});

What will be the response if the user sends { "email": "userexample.com", "age": 17 }?

medium

A. Status 400 with error about missing fields

B. Status 400 with errors about invalid email and age

C. Status 500 server error

D. Status 200 with message 'Data is valid'

Solution

1. Step 1: Analyze validation rules

   The code checks if 'email' is a valid email and 'age' is an integer >= 18.

2. Step 2: Check input values

   The email 'userexample.com' is missing '@', so invalid. Age 17 is less than 18, so invalid.

3. Final Answer:

   Status 400 with errors about invalid email and age -> Option B

4. Quick Check:

   Invalid email and age cause 400 error [OK]

Hint: Invalid inputs trigger 400 with error details [OK]

Common Mistakes:

• Assuming invalid data passes validation
• Confusing status codes
• Ignoring validationResult usage

4. You wrote this code to sanitize input but it doesn't remove spaces as expected:

app.post('/data', [
  check('username').trim().escape()
], (req, res) => {
  // ...
});

What is the likely reason the spaces are not removed?

medium

A. You must call sanitize() before trim()

B. escape() removes spaces but trim() does not

C. The trim() method removes spaces only from start and end, not inside the string

D. The check() function does not support trim()

Solution

1. Step 1: Understand trim() behavior

   The trim() method removes whitespace only from the start and end of a string, not inside it.

2. Step 2: Check escape() effect

   escape() converts special characters but does not remove spaces inside the string.

3. Final Answer:

   The trim() method removes spaces only from start and end, not inside the string -> Option C

4. Quick Check:

   trim() trims edges, not inner spaces [OK]

Hint: trim() only removes spaces at string ends [OK]

Common Mistakes:

• Expecting trim() to remove all spaces
• Misunderstanding escape() purpose
• Thinking check() lacks trim() support

5. You want to create a Node.js API endpoint that accepts a username and email. The username must be alphanumeric and trimmed, and the email must be valid and normalized. Which express-validator chain correctly applies validation and sanitization?

hard

A. [ check('username').trim().isAlphanumeric(), check('email').normalizeEmail().isEmail() ]

B. [ check('username').isAlphanumeric().trim(), check('email').isEmail().normalizeEmail() ]

C. [ check('username').escape().isAlphanumeric(), check('email').isEmail().trim() ]

D. [ check('username').isAlphanumeric().escape(), check('email').trim().normalizeEmail() ]

Solution

1. Step 1: Validate username and email correctly

   Username must be alphanumeric and trimmed, so trim() before or after is okay but isAlphanumeric() must check the trimmed string. Email must be checked with isEmail() and normalized with normalizeEmail().

2. Step 2: Analyze options

   [ check('username').trim().isAlphanumeric(), check('email').normalizeEmail().isEmail() ] applies trim() before isAlphanumeric() which ensures validation on trimmed string; [ check('username').isAlphanumeric().trim(), check('email').isEmail().normalizeEmail() ] applies isAlphanumeric() before trim(), which may validate untrimmed input; also, normalizeEmail() should come before isEmail() to validate normalized email; [ check('username').escape().isAlphanumeric(), check('email').isEmail().trim() ] escapes username unnecessarily and trims email which is not needed; [ check('username').isAlphanumeric().escape(), check('email').trim().normalizeEmail() ] escapes username and trims email incorrectly.

3. Final Answer:

   [ check('username').trim().isAlphanumeric(), check('email').normalizeEmail().isEmail() ] -> Option A

4. Quick Check:

   Trim before validation for username; normalize before validation for email [OK]

Hint: Trim before validation for username; normalize before validation for email [OK]

Common Mistakes:

• Applying sanitization after validation incorrectly
• Using escape() unnecessarily
• Trimming email instead of normalizing