Manual validation patterns in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the response when missing required field in manual validation?

Consider this Express route that manually validates a JSON body for a required username field. What will the server respond if the client sends an empty JSON object {}?

Express

app.post('/register', (req, res) => {
  const { username } = req.body;
  if (!username) {
    return res.status(400).json({ error: 'Username is required' });
  }
  res.status(200).json({ message: `Welcome, ${username}!` });
});

A Status 200 with JSON { message: 'Welcome, undefined!' }

B Status 400 with JSON { error: 'Username is required' }

C Status 500 with server error message

D Status 404 with empty response

💡 Hint

Check the condition that tests if username exists before sending success response.

The code checks if username is missing and returns a 400 status with an error message. Sending empty JSON means username is undefined, so the error response is sent.

📝 Syntax

intermediate

Identify the syntax error in this manual validation middleware

This Express middleware is intended to check if email exists in the request body. Which option correctly identifies the syntax error?

Express

function validateEmail(req, res, next) {
  if (!req.body.email) {
    res.status(400).json({ error: 'Email required' });
  } else {
    next();
  }
}

A Missing semicolon after res.status(400).json(...) causes syntax error

B Incorrect use of arrow function syntax

C Missing return statement after sending response causes next() to run anyway

D No syntax error; code is valid

💡 Hint

Think about what happens after sending a response without return.

Without a return after sending the error response, next() will still be called, which can cause unexpected behavior. This is a logic error, not a syntax error, but it is the main issue here.

❓ state_output

advanced

What is the output when validating multiple fields manually?

Given this Express route that manually validates username and password, what JSON response will the client receive if username is provided but password is missing?

Express

app.post('/login', (req, res) => {
  const { username, password } = req.body;
  if (!username) {
    return res.status(400).json({ error: 'Username required' });
  }
  if (!password) {
    return res.status(400).json({ error: 'Password required' });
  }
  res.status(200).json({ message: `User ${username} logged in` });
});

A { error: 'Password required' } with status 400

B { error: 'Username required' } with status 400

C { message: 'User undefined logged in' } with status 200

D { message: 'User username logged in' } with status 200

💡 Hint

Check the order of validation checks and which field is missing.

Since username is present, the first if is skipped. The second if detects missing password and returns the error JSON with status 400.

🔧 Debug

advanced

Why does this manual validation middleware allow invalid emails?

This middleware is supposed to reject requests with invalid email format. Why does it fail to do so?

Express

function checkEmailFormat(req, res, next) {
  const email = req.body.email;
  if (!email || email.indexOf('@') === -1) {
    res.status(400).json({ error: 'Invalid email' });
  } else {
    next();
  }
}

A email is undefined when body is empty, causing runtime error

B indexOf('@') returns -1 for valid emails, so condition is wrong

C Middleware is not attached to any route, so never runs

D Missing return after res.status(400)... causes next() to run even on invalid email

💡 Hint

What happens after sending a response without stopping execution?

Without return, next() runs even if email is invalid, allowing the request to proceed. This bypasses the intended validation.

🧠 Conceptual

expert

Which manual validation pattern best prevents multiple responses in Express?

In manual validation, what is the best pattern to ensure the server sends only one response and does not call next() after sending an error?

A Always use 'return' before sending a response to stop further code execution

B Call next() immediately after sending a response to continue middleware chain

C Use try-catch blocks around validation and call next() in finally block

D Send multiple responses but handle errors on client side

💡 Hint

Think about how JavaScript functions stop running after return.

Using 'return' before sending a response stops the function from running further, preventing multiple responses or calling next() after response.