Dynamic Routing & Middleware

When building a RESTful API, you don't create a distinct route for every user in your database. Instead, you define a scalable pattern.

By placing a colon (:) in the URL path (e.g., /products/:productId), you tell Express to catch whatever value is passed in that specific segment of the URL and store it as a dynamic variable. This variable becomes instantly accessible inside your route's callback function via the req.params object.

app.get('/users/:userId', (req, res) => {
  const id = req.params.userId;
  // Query database for user with this ID
});

This is the exact mechanic Twitter uses to load your specific profile when you visit twitter.com/yourusername. The single route /users/:username handles millions of profiles.

While GET requests pass small amounts of data through the URL, POST and PUT requests require passing large data payloads (like a user registration form). This data is attached to the request 'Body'.

However, when data travels across the internet, it travels as a raw string of text. When this text hits your Express server, Express doesn't automatically assume it's JSON. If you attempt to read req.body.email in a brand new Express application, it will return undefined and crash your application.

Express requires explicit instructions on how to handle incoming string payloads.

To instruct Express to parse JSON, we use Middleware.

Middleware is a function that has access to the Request and Response objects *before* they reach your final route callback. Think of it as a factory assembly line. A request comes in, the JSON middleware intercepts it and parses the body, an authentication middleware might verify a token, and *finally*, your specific app.post logic executes.

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

// The Assembly Line Middleware
app.use(express.json());

// The Route Callback
app.post('/users', (req, res) => {
  console.log(req.body.email); // Now this works!
});

The app.use(express.json()) command tells Express: 'Intercept every incoming request. If the request has a JSON string in its body, parse it into a native JavaScript object and attach it to req.body.' It is arguably the most important configuration line in any Node.js server.

Advanced Express Routing. A basic API route maps an exact URL (like /users) to a static response. But real applications require dynamic routing. For example, if you want to view a specific user's profile, you don't write 1,000 different routes for 1,000 different users. You write a single, dynamic route. In Express, you do this using 'Route Parameters'. By placing a colon (:) before a word in the URL path, you tell Express that this section of the URL is a dynamic variable.

Extracting Parameters (req.params). When a user visits /users/42, the Express server captures that 42 and places it inside the req (Request) object. Specifically, it is stored in req.params. Because you named the variable :id in the route definition, you can access it via req.params.id. You can then use this ID to query your database for that exact user. This allows a single block of code to handle infinite URLs.

You define an Express route as app.get('/products/:productId', ...). When a user visits /products/999, how do you access the number '999' inside your callback function?

• →req.body.productId
• →req.params.productId

Reading JSON (req.body). While GET requests use the URL to pass data (req.params), POST and PUT requests use the request 'Body' to pass large JSON payloads (like form data). In Express, this payload is attached to req.body. However, out of the box, Express does not know how to read JSON strings. If you try to log req.body, it will return undefined. You must explicitly tell Express to parse incoming JSON by adding middleware.

The Body Parser Middleware. To fix the undefined body issue, you must configure your Express app. Before you define any of your routes, you add a single line of code: app.use(express.json()). This is called 'Middleware'. It intercepts every single incoming request. If it sees a JSON string in the request body, it automatically parses it into a usable JavaScript object and attaches it to req.body *before* your route callback executes.

If you write an app.post route, but req.body is completely undefined when you try to log it, what line of code did you most likely forget to add to the top of your server file?

• →app.use(cors())
• →app.use(express.json())

Database Integration. You now have a fully functional API. You can read dynamic URL parameters and parse incoming JSON payloads. However, if the server restarts, all your data is lost because we are just storing it in memory (RAM). Real applications persist data forever. In the final module, we will connect our Express API to a real Database, completing the full-stack lifecycle.