Request and response schemas in Express - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a request schema in Express?

A request schema defines the expected structure and types of data sent by the client in an HTTP request. It helps validate and ensure the request data is correct before processing.

beginner

Why use response schemas in Express?

Response schemas define the structure and types of data sent back to the client. They help keep API responses consistent and predictable, making it easier for clients to handle the data.

intermediate

Which library is commonly used with Express to define and validate request and response schemas?

Joi is a popular library used to define and validate request and response schemas in Express applications.

intermediate

How does schema validation improve API reliability?

Schema validation catches errors early by checking if incoming requests and outgoing responses match expected formats. This prevents bugs and security issues caused by unexpected data.

intermediate

What is the typical flow when using request and response schemas in Express?

First, the request data is validated against the request schema. If valid, the server processes the request and prepares a response. Before sending, the response data is validated against the response schema to ensure correctness.

What does a request schema in Express mainly validate?

A Data sent by the client in the HTTP request

B Data sent by the server in the HTTP response

C The server's internal variables

D The database schema

Request schemas validate the data sent by the client in the HTTP request to ensure it matches expected structure and types.

Which library is commonly used to define schemas in Express apps?

A React

B Lodash

C Joi

D Express-validator

Joi is a popular library for defining and validating schemas in Express applications.

What happens if request data does not match the schema?

A The server rejects the request with an error

B The server ignores the error and processes the request

C The server crashes

D The server sends a success response anyway

If request data fails schema validation, the server usually rejects the request and sends an error response.

Why validate response data with a schema?

A To speed up the server

B To ensure the client receives data in the expected format

C To encrypt the data

D To change the data format randomly

Validating response data ensures the client gets data in the expected format, improving reliability.

When is response schema validation usually done?

A During server startup

B Before receiving the request

C After the client receives the data

D Before sending data back to the client

Response schema validation is done before sending data back to the client to ensure correctness.

Explain how request and response schemas help improve an Express API.

Think about how schemas check data before processing and before sending back.

Describe the typical steps to use a request schema in an Express route.

Focus on defining, validating, error handling, and processing.

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