Express.js Mastery / Express: Let’s Start Building The Natours API!

Creating Our Own Middleware

📖 Context

Now that middleware and the request-response cycle concept have been covered, it's time to actually write custom middleware functions in code.

🔄 Recap: Middleware Already Used

express.json() was already used earlier via app.use(). Calling express.json() returns a function, and that function gets added to the middleware stack. app.use() is the method used to add any middleware to the stack.

🔹 Step 1: Writing a Basic Custom Middleware Function

app.use((req, res, next) => {
  console.log('Hello from the middleware 👋');
  next();
});

💡 Why each part works:

  • 🧩 app.use() — registers this function as middleware, adding it to the middleware stack.

  • 📦 The function takes three arguments: req, res, and next. Having a third argument is what tells Express "this is middleware" — Express automatically passes the next function as the third argument.

  • 🏷️ Naming conventions (req, res, next) aren't mandatory — the arguments could technically be named anything (e.g. x, n) — but sticking to convention avoids confusion for anyone reading the code.

  • 🖨️ console.log(...) — just some placeholder code to prove the middleware runs on each request.

  • ⚠️ next() — critical: without calling next(), the request-response cycle would get stuck at this point. The app would never move on to send a response back to the client. Forgetting to call next() is one of the most important mistakes to avoid in Express.

🔹 Step 2: Testing — Middleware Applies to Every Request

📤 Sending a request to any route (e.g. Get All Tours) — the console logs:

✅ This confirms that this middleware (defined without a specific route) applies to every single request — but only if it's positioned before the relevant route handler in the code.

🔹 Step 3: Understanding Order — Moving the Middleware After a Route Handler

🧪 Demonstration

The middleware function is moved to after the getAllTours route handler in the code.

📋 Result

Sending a request to that same route → Hello from the middleware 👋 is not logged anymore.

💡 Why this happens:

  • Route handlers are themselves a type of middleware — just middleware limited to a specific URL.

  • getAllTours calls res.json(...), which ends the request-response cycle right there.

  • Since the cycle has already finished by the time it would reach the custom middleware, that middleware is simply never called.

  • This proves that order matters fundamentally in Express — middleware placed after a route handler that sends a response will never run for that route.

✅ Confirming with Another Route

📤 Sending a request to a different route (e.g. Get Tour, Update Tour, or Delete Tour) — Hello from the middleware 👋 does appear, because for this route, the middleware still comes before its handler in the overall stack.

  • Send back the middleware to the previous place

⭐ Best Practice

Global middleware like this should generally be defined before all route handlers, so it consistently runs for every request.

🔹 Step 4: A Second Middleware — Manipulating the Request Object

This middleware adds a custom property to the request object: a timestamp of when the request occurred.

app.use((req, res, next) => {
  req.requestTime = new Date().toISOString();
  next();
});

💡 Why it works

  • 📦 Uses the standard middleware signature: req, res, next.

  • 🏷️ req.requestTime = new Date().toISOString() adds a custom timestamp to the request object.

  • 🕒 .toISOString() converts the date into a readable string.

  • ⚠️ next() passes control to the next middleware or route handler.

🔹 Step 5: Using the Custom Request Property in a Route Handler

Inside getAllTours, the injected requestTime can now be logged or included in the response:

const getAllTours = (req, res) => {
  console.log(req.requestTime);

  res.status(200).json({
    status: 'success',
    requestedAt: req.requestTime,
    // ...existing response data
  });
};

🧪 Testing Result

The response correctly includes requestedAt with the current date/time — proving the value came from the custom middleware, since it was never defined inside the route handler itself.

🔑 Key Takeaways

  • 🧩 Use app.use() to register middleware.

  • ⚙️ Middleware functions use the (req, res, next) signature.

  • ⚠️ Always call next() to continue the request-response cycle.

  • 📋 Middleware executes in the order it's defined.

  • 🏷️ Middleware can modify the req object (e.g., add requestTime).

  • 📍 Place global middleware before your route handlers.