Request and response schemas in Express - Step-by-Step Execution

Concept Flow - Request and response schemas

Client sends request

↓

Server receives request

↓

Validate request schema

Yes / No↓

Send error

↓

Prepare response data

↓

Validate response schema

Yes / No↓

Send error

↓

Client receives response

This flow shows how a server checks the request data matches a schema before processing, then validates the response data before sending it back.

Execution Sample

Express

const schema = {
  body: { name: 'string', age: 'number' },
};

const validate = (data, sch) => {
  for (const [key, type] of Object.entries(sch)) {
    if (typeof data[key] !== type) {
      return false;
    }
  }
  return true;
};

app.post('/user', (req, res) => {
  const validationResult = validate(req.body, schema.body);
  if (!validationResult) {
    return res.status(400).send('Invalid data');
  }
  const response = { message: `Hello, ${req.body.name}` };
  res.send(response);
});

This code checks the request body matches the schema before responding with a greeting message.

Execution Table

Step	Action	Request Body	Validation Result	Response Sent
1	Receive request	{ name: 'Alice', age: 30 }	Not checked yet	None
2	Validate request body	{ name: 'Alice', age: 30 }	Valid	None
3	Process request	{ name: 'Alice', age: 30 }	Valid	None
4	Prepare response	{ name: 'Alice', age: 30 }	Valid	{ message: 'Hello, Alice' }
5	Send response	{ name: 'Alice', age: 30 }	Valid	{ message: 'Hello, Alice' }
6	Request complete	{ name: 'Alice', age: 30 }	Valid	Response sent

💡 Request ends after sending valid response or error if validation fails

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
req.body	undefined	{ name: 'Alice', age: 30 }	{ name: 'Alice', age: 30 }	{ name: 'Alice', age: 30 }
validationResult	undefined	true	true	true
response	undefined	undefined	{ message: 'Hello, Alice' }	{ message: 'Hello, Alice' }

Key Moments - 3 Insights

Why do we validate the request body before processing?

Validating early (see step 2 in execution_table) prevents processing bad or unexpected data, avoiding errors later.

What happens if the request body does not match the schema?

The server sends an error response immediately (not shown in this trace), stopping further processing.

Why validate the response before sending it?

Validating response ensures the server sends data in the expected format, keeping client and server in sync.

Visual Quiz - 3 Questions

Look at the execution_table, what is the validation result at step 2?

A Invalid

B Valid

C Not checked yet

D Error

💡 Hint

Check the 'Validation Result' column at step 2 in execution_table

At which step is the response prepared?

A Step 1

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' column in execution_table for when response is created

If the request body was missing the 'age' field, what would happen at step 2?

A Validation would fail and send error

B Response would be sent anyway

C Validation would pass

D Server would crash

💡 Hint

Refer to key_moments about request validation and error sending

Concept Snapshot

Request and response schemas in Express:
- Validate incoming request data matches schema before processing
- If invalid, send error response immediately
- Process valid requests and prepare response data
- Validate response data matches schema before sending
- Helps keep client-server data consistent and safe

Full Transcript

In Express, when a client sends a request, the server first checks if the request data matches a defined schema. This validation step ensures the data is correct and safe to use. If the data is invalid, the server sends an error response and stops processing. If valid, the server processes the request, prepares the response data, and then validates the response against a schema before sending it back. This double validation keeps communication clear and prevents errors. The execution table shows each step: receiving the request, validating, processing, preparing response, and sending it. Variables like request body, validation result, and response data change as the server works through these steps.

Practice

1. What is the main purpose of using request and response schemas in an Express app?

easy

A. To define and validate the shape of data sent and received

B. To speed up the server response time

C. To style the API responses with colors

D. To automatically generate HTML pages

Solution

1. Step 1: Understand the role of schemas

   Request and response schemas specify what data structure is expected, helping to validate inputs and outputs.

2. Step 2: Identify the main benefit

   This validation helps catch errors early and keeps the API clear and consistent.

3. Final Answer:

   To define and validate the shape of data sent and received -> Option A

4. Quick Check:

   Schema purpose = validation [OK]

Hint: Schemas check data shape to avoid errors [OK]

Common Mistakes:

• Thinking schemas improve speed directly
• Confusing schemas with styling tools
• Assuming schemas generate HTML automatically

2. Which of the following is the correct way to use a schema validation middleware in Express for a POST request body?

easy

A. app.get('/user', validateSchema, (req, res) => { ... })

B. app.post('/user', validateSchema, (req, res) => { ... })

C. app.post('/user', (req, res) => validateSchema(req.body))

D. app.use(validateSchema('/user'))

Solution

1. Step 1: Identify correct HTTP method and middleware usage

   Schema validation middleware should be used in the route handler chain, typically for POST requests when validating request bodies.

2. Step 2: Check syntax correctness

   app.post('/user', validateSchema, (req, res) => { ... }) correctly places the middleware function before the route handler for POST '/user'.

3. Final Answer:

   app.post('/user', validateSchema, (req, res) => { ... }) -> Option B

4. Quick Check:

   Middleware before handler for POST = B [OK]

Hint: Middleware goes between route and handler [OK]

Common Mistakes:

• Using GET instead of POST for body validation
• Calling middleware inside handler instead of chaining
• Using app.use incorrectly with route path

3. Given this Express route using Joi schema validation middleware:

const schema = Joi.object({ name: Joi.string().required() });
app.post('/data', (req, res, next) => {
  const { error } = schema.validate(req.body);
  if (error) return res.status(400).send(error.message);
  res.send('Valid data');
});

What will the response be if the client sends {} as JSON body?

medium

A. Valid data

B. 500 Internal Server Error

C. 400 Bad Request with error message

D. Empty response with status 200

Solution

1. Step 1: Analyze schema requirements

   The schema requires a 'name' string field that is mandatory.

2. Step 2: Check validation result for empty body

   Sending an empty object {} misses the required 'name', so validation fails and error is returned with status 400.

3. Final Answer:

   400 Bad Request with error message -> Option C

4. Quick Check:

   Missing required field = 400 error [OK]

Hint: Missing required fields cause 400 error [OK]

Common Mistakes:

• Assuming empty body passes validation
• Expecting 500 error on validation failure
• Thinking success message is sent regardless

4. Consider this Express route snippet with schema validation:

app.post('/item', (req, res) => {
  const { id, price } = req.body;
  if (typeof id !== 'number' || typeof price !== 'number') {
    res.status(400).send('Invalid data');
    return;
  }
  res.send('Item accepted');
});

What is the main bug in this code?

medium

A. It does not stop execution after sending 400 response

B. It uses wrong HTTP method for data submission

C. It does not parse JSON body before accessing req.body

D. It sends response twice causing server crash

Solution

1. Step 1: Check response flow after validation failure

   After sending 400 response, the code continues and sends 'Item accepted' response, causing multiple responses.

2. Step 2: Identify missing control flow

   There is no return or else to stop execution after sending error response.

3. Final Answer:

   It does not stop execution after sending 400 response -> Option A

4. Quick Check:

   Send response then stop = return [OK]

Hint: Return after res.send to stop code [OK]

Common Mistakes:

• Ignoring missing return after error response
• Assuming Express auto-stops after res.send
• Confusing HTTP method correctness

5. You want to create an Express route that accepts a JSON body with an array of user objects, each having a required 'email' string and optional 'age' number. Which Joi schema correctly validates this request body?

hard

A. Joi.object({ users: Joi.array().required() })

B. Joi.object({ email: Joi.string().required(), age: Joi.number() }).required()

C. Joi.array().items(Joi.string().email().required())

D. Joi.array().items(Joi.object({ email: Joi.string().email().required(), age: Joi.number() }))

Solution

1. Step 1: Understand the data shape

   The body is an array of user objects, each with required 'email' string and optional 'age' number.

2. Step 2: Match schema to data shape

   Joi.array().items(Joi.object({ email: Joi.string().email().required(), age: Joi.number() })) defines an array of objects with the correct fields and validations.

3. Final Answer:

   Joi.array().items(Joi.object({ email: Joi.string().email().required(), age: Joi.number() })) -> Option D

4. Quick Check:

   Array of objects with required email = A [OK]

Hint: Use array().items(object({...})) for arrays of objects [OK]

Common Mistakes:

• Using object schema instead of array for array data
• Validating array of strings instead of objects
• Missing required email validation