Schema validation in Express - Mini Project: Build & Apply

Schema validation in Express

📖 Scenario: You are building a simple Express server that accepts user data via a POST request. To keep your server safe and reliable, you want to check that the data sent by users matches the expected format before processing it.

🎯 Goal: Build an Express server that validates incoming JSON data against a schema using a middleware function. The server should only accept requests where the data matches the schema.

📋 What You'll Learn

Create an Express app with a POST route at /users

Define a schema object that requires name as a string and age as a number

Write a middleware function called validateUser that checks the request body against the schema

Use the validateUser middleware in the /users route to accept only valid data

💡 Why This Matters

🌍 Real World

Validating user input on a server is essential to prevent errors and security issues. This project shows how to do basic validation in Express before processing data.

💼 Career

Backend developers often write validation middleware to ensure APIs receive correct data. This skill is fundamental for building reliable and secure web services.

1

Set up Express app and user schema

Create an Express app by requiring express and calling express(). Then create a constant called userSchema that is an object with keys name set to "string" and age set to "number".

Express

const express = require('express');
const app = express();

// Your code here

Hint

Use require('express') to import Express and express() to create the app. Define userSchema as an object with the exact keys and string values.

2

Add JSON body parsing middleware

Add the Express middleware to parse JSON request bodies by calling app.use(express.json()).

Express

const express = require('express');
const app = express();

const userSchema = {
  name: "string",
  age: "number"
};

// Your code here

Hint

Use app.use(express.json()) to enable JSON parsing for incoming requests.

3

Create the validateUser middleware function

Write a middleware function called validateUser that takes req, res, and next as parameters. Inside, check that req.body.name is a string and req.body.age is a number. If valid, call next(). Otherwise, respond with status 400 and JSON message { error: "Invalid user data" }.

Express

const express = require('express');
const app = express();

const userSchema = {
  name: "string",
  age: "number"
};

app.use(express.json());

// Your code here

Hint

Check the types of req.body.name and req.body.age using typeof. Call next() if valid, else send a 400 error response.

4

Add POST /users route with validation middleware

Add a POST route at /users using app.post. Use the validateUser middleware for this route. In the route handler, respond with JSON { message: "User data is valid" }.

Express

const express = require('express');
const app = express();

const userSchema = {
  name: "string",
  age: "number"
};

app.use(express.json());

function validateUser(req, res, next) {
  if (typeof req.body.name === 'string' && typeof req.body.age === 'number') {
    next();
  } else {
    res.status(400).json({ error: "Invalid user data" });
  }
}

// Your code here

Hint

Use app.post with the path '/users', add validateUser as middleware, and send a JSON success message in the handler.

Practice

1. What is the main purpose of schema validation in an Express app?

easy

A. To store data permanently in the database

B. To speed up the server response time

C. To style the user interface automatically

D. To check if incoming data matches expected rules before processing

Solution

1. Step 1: Understand schema validation role

   Schema validation ensures data received matches rules like type and format.

2. Step 2: Identify main purpose in Express

   It prevents bad data from causing errors or security issues by checking before use.

3. Final Answer:

   To check if incoming data matches expected rules before processing -> Option D

4. Quick Check:

   Schema validation = data check before use [OK]

Hint: Schema validation means checking data fits rules before use [OK]

Common Mistakes:

• Thinking validation speeds up server
• Confusing validation with UI styling
• Assuming validation stores data

2. Which of the following is the correct way to define a Joi schema for a required string named username?

easy

A. const schema = Joi.object({ username: Joi.string().required() });

B. const schema = Joi.string().required();

C. const schema = Joi.string().optional();

D. const schema = Joi.number().required();

Solution

1. Step 1: Recall Joi schema structure for objects

   Joi schemas for objects use Joi.object({ key: rule }) format.

2. Step 2: Check correct rule for required string property

   Property username must be a string and required, so use Joi.string().required().

3. Final Answer:

   const schema = Joi.object({ username: Joi.string().required() }); -> Option A

4. Quick Check:

   Object schema with required string property = const schema = Joi.object({ username: Joi.string().required() }); [OK]

Hint: Use Joi.object({ key: Joi.type().required() }) for required fields [OK]

Common Mistakes:

• Defining schema as Joi.string() alone for object data
• Using optional() instead of required()
• Using wrong data type like Joi.number() for string

3. Given this Joi schema and data, what will schema.validate(data) return?

const schema = Joi.object({ age: Joi.number().min(18).required() });
const data = { age: 16 };

medium

A. Validation fails because age is less than 18

B. Validation passes with value { age: 16 }

C. Validation fails because age is missing

D. Validation passes with value { age: 18 }

Solution

1. Step 1: Analyze schema rules for age

   Age must be a number, minimum 18, and required.

2. Step 2: Check data against schema

   Data has age 16, which is less than minimum 18, so validation fails.

3. Final Answer:

   Validation fails because age is less than 18 -> Option A

4. Quick Check:

   Age < 18 fails min rule = Validation fails because age is less than 18 [OK]

Hint: Check min/max rules carefully when validating numbers [OK]

Common Mistakes:

• Assuming 16 passes min(18) rule
• Confusing missing field with invalid value
• Thinking Joi changes value automatically

4. What is wrong with this Express route using Joi validation?

app.post('/user', (req, res) => {
  const schema = Joi.object({ email: Joi.string().email().required() });
  const result = schema.validate(req.body.email);
  if (result.error) {
    res.status(400).send('Invalid email');
  } else {
    res.send('User created');
  }
});

medium

A. It does not call next() after validation

B. It validates only the email string, not the whole object

C. It uses res.send instead of res.json

D. It should use Joi.number() for email

Solution

1. Step 1: Check what is validated

   The schema expects an object with an email property, but code validates req.body.email (a string).

2. Step 2: Understand Joi object validation

   To validate the whole object, pass req.body to schema.validate, not just one property.

3. Final Answer:

   It validates only the email string, not the whole object -> Option B

4. Quick Check:

   Validate whole object, not single property [OK]

Hint: Validate req.body object, not a single field string [OK]

Common Mistakes:

• Validating only a property instead of full object
• Confusing res.send and res.json (both work)
• Forgetting to call next() is not required here
• Using wrong Joi type for email

5. You want to validate a user object with optional phone that must be a string of 10 digits if present, and a required name string. Which Joi schema correctly enforces this?

hard

A. Joi.object({ name: Joi.string().required(), phone: Joi.string().pattern(/\d+/).required() })

B. Joi.object({ name: Joi.string(), phone: Joi.number().length(10).optional() })

C. Joi.object({ name: Joi.string().required(), phone: Joi.string().pattern(/^\d{10}$/).optional() })

D. Joi.object({ name: Joi.string().required(), phone: Joi.string().length(10).required() })

Solution

1. Step 1: Identify required and optional fields

   Name is required string; phone is optional string matching exactly 10 digits.

2. Step 2: Check regex pattern and optional usage

   Pattern /^\d{10}$/ matches exactly 10 digits; phone is optional, so use .optional().

3. Step 3: Eliminate incorrect options

   Other options make phone required, use wrong types like Joi.number(), apply invalid methods like .length(10) on numbers, or use loose patterns like /\d+/.

4. Final Answer:

   Joi.object({ name: Joi.string().required(), phone: Joi.string().pattern(/^\d{10}$/).optional() }) -> Option C

5. Quick Check:

   Required name + optional 10-digit phone pattern = Joi.object({ name: Joi.string().required(), phone: Joi.string().pattern(/^\d{10}$/).optional() }) [OK]

Hint: Use .pattern(/^\d{10}$/) for exact 10-digit string [OK]

Common Mistakes:

• Using Joi.number() for phone instead of string
• Making optional field required
• Using .length(10) on string without pattern
• Using loose regex that allows wrong formats