Why REST principles matter in Express - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use statelessness in REST APIs?

In REST, statelessness means each request from client to server must contain all the information needed to understand and process the request. Why is this important?

A It forces the server to remember client sessions, making the API faster.

B It allows the server to handle each request independently, improving scalability and reliability.

C It requires the client to store all server data, reducing server load.

D It makes the API stateful, so the server can track user progress easily.

💡 Hint

Think about how servers handle many users at once without mixing their data.

Statelessness means the server does not keep client context between requests. This makes scaling easier because any server can handle any request without needing previous information.

❓ component_behavior

intermediate

What happens if REST APIs don't use proper HTTP methods?

Consider a REST API built with Express that uses POST for all actions, including data retrieval. What is a likely consequence?

A Clients and intermediaries cannot cache responses properly, reducing performance.

B The API will automatically become faster because POST is always faster than GET.

C The API will reject all requests due to method mismatch errors.

D The server will store session data for each POST request.

💡 Hint

Think about how browsers and proxies handle GET vs POST requests.

Using POST for all actions prevents caching because POST requests are not cached by default. This can slow down the API and increase server load.

❓ state_output

advanced

What is the output of this Express route following REST principles?

Given this Express route, what JSON response will the client receive when requesting GET /users/42? ```js const express = require('express'); const app = express(); const users = { 42: { id: 42, name: 'Alice' } }; app.get('/users/:id', (req, res) => { const user = users[req.params.id]; if (!user) { return res.status(404).json({ error: 'User not found' }); } res.json(user); }); // Assume server is running and client requests GET /users/42 ```

Express

const express = require('express');
const app = express();
const users = { 42: { id: 42, name: 'Alice' } };

app.get('/users/:id', (req, res) => {
  const user = users[req.params.id];
  if (!user) {
    return res.status(404).json({ error: 'User not found' });
  }
  res.json(user);
});

A {"id":42,"name":"Alice"}

B {"error":"User not found"}

C 404 Not Found with empty body

D {"id":"42","name":"Alice"}

💡 Hint

Look at how the user object is retrieved and returned as JSON.

The route finds the user with id 42 and returns it as JSON with status 200. The id is a number, so the JSON reflects that.

📝 Syntax

advanced

Which Express route correctly implements RESTful DELETE for a resource?

Choose the correct Express route syntax to delete a user by id following REST principles.

A app.put('/users/:id/delete', (req, res) => { /* delete logic */ });

B app.post('/users/delete/:id', (req, res) => { /* delete logic */ });

C app.get('/users/:id/delete', (req, res) => { /* delete logic */ });

D app.delete('/users/:id', (req, res) => { /* delete logic */ });

💡 Hint

REST uses HTTP DELETE method to remove resources.

RESTful APIs use the DELETE method on the resource URL to delete it. Using POST, GET, or PUT for delete actions breaks REST conventions.

🔧 Debug

expert

Why does this Express REST API fail to scale properly?

Consider this Express server code snippet: ```js const express = require('express'); const app = express(); let sessionData = {}; app.post('/login', (req, res) => { const userId = req.body.userId; sessionData[userId] = { loggedIn: true }; res.json({ message: 'Logged in' }); }); app.get('/profile', (req, res) => { const userId = req.query.userId; if (sessionData[userId]?.loggedIn) { res.json({ profile: 'User profile data' }); } else { res.status(401).json({ error: 'Not logged in' }); } }); app.listen(3000); ``` What is the main reason this design violates REST principles and causes scaling problems?

Express

const express = require('express');
const app = express();
let sessionData = {};

app.post('/login', (req, res) => {
  const userId = req.body.userId;
  sessionData[userId] = { loggedIn: true };
  res.json({ message: 'Logged in' });
});

app.get('/profile', (req, res) => {
  const userId = req.query.userId;
  if (sessionData[userId]?.loggedIn) {
    res.json({ profile: 'User profile data' });
  } else {
    res.status(401).json({ error: 'Not logged in' });
  }
});

app.listen(3000);

A The server does not validate userId format, causing security issues.

B The server uses POST for login instead of GET, which is not allowed in REST.

C The server stores session state in memory, breaking statelessness and preventing horizontal scaling.

D The server listens on port 3000, which is reserved and causes conflicts.

💡 Hint

Think about what statelessness means for REST and how storing data in memory affects multiple servers.

REST requires stateless servers. Storing session data in memory means requests depend on server memory, so scaling with multiple servers fails because session data is not shared.