Understanding Route & Request Flow in Node.js MVC | Beginner-Friendly Guide

Learn MVC - The easiest way

---

🧠 Introduction

When working on backend projects using Node.js + Express, most beginners struggle with this question:

❓ “How does a route actually flow through the app? From client → to controller → to response?”

In this post, we’ll break down every step of a request — using a simple Candy Store app built in MVC architecture.

You’ll learn:

• What happens when a route is called

• The GET vs POST flow

• The role of router, controller, and model

• And how to make your project clean and scalable

With code examples included ✅

---

📁 Project Folder Structure (MVC Pattern)

/project-root
│
├── controllers/
│   └── authController.js
│
├── models/
│   └── user-model.js
│
├── routes/
│   └── authRoutes.js
│
├── utils/
│   └── token-generator.js
│
├── views/
│   ├── home.ejs
│   ├── register.ejs
│   └── login.ejs
│
├── app.js or server.js

This structure helps us separate logic and makes the project easy to scale and debug.

---

🔄 Full Route Flow Breakdown

Let’s walk through an actual example:

1️⃣ Client Sends Request

User opens the browser and visits:

GET /

This request first hits your main app.js.

---

2️⃣ app.js Handles Base Routes

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

const authRoutes = require("./routes/authRoutes");

app.use("/", authRoutes);

app.listen(5000, () => {
  console.log("Server is running on port 5000");
});

The app says:

“All / related routes are handled by authRoutes.”

Now the request moves to authRoutes.js.

---

3️⃣ Routes File Handles Path Matching

const express = require("express");
const router = express.Router();
const { registerUser, loginUser, logoutUser } = require("../controllers/authController");

router.get("/", (req, res) => {
  res.render("home"); // home.ejs will be rendered
});

router.get("/register", (req, res) => {
  res.render("register");
});

router.post("/register", registerUser);

router.get("/login", (req, res) => {
  res.render("login");
});

router.post("/login", loginUser);

router.get("/logout", logoutUser);

module.exports = router;

🔑 This is where the real routing logic lives:

• GET /register → Render register page

• POST /register → Call registerUser() controller function

---

4️⃣ Controller Logic Handles Business Logic

// controllers/authController.js

const User = require("../models/user-model");
const bcrypt = require("bcrypt");
const generateToken = require("../utils/token-generator");

exports.registerUser = async (req, res) => {
  try {
    const { name, email, password } = req.body;

    // Check if user already exists
    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(400).send("User already exists");
    }

    // Hash password
    const salt = await bcrypt.genSalt(10);
    const hashedPassword = await bcrypt.hash(password, salt);

    // Create new user
    const newUser = new User({ name, email, password: hashedPassword });
    await newUser.save();

    // Generate JWT token
    const token = generateToken(newUser._id);

    // Send token as a cookie
    res.cookie("jwt", token, { httpOnly: true });

    res.redirect("/");
  } catch (err) {
    res.status(500).send("Error registering user");
  }
};

This controller:

• Handles form data

• Checks for existing user

• Hashes the password using bcrypt

• Creates a user in DB

• Generates a JWT token

• Sets the token in a secure cookie

---

5️⃣ User Model Talks to MongoDB

// models/user-model.js

const mongoose = require("mongoose");

const userSchema = new mongoose.Schema({
  name: String,
  email: { type: String, unique: true },
  password: String
});

module.exports = mongoose.model("User", userSchema);

This file handles data schema — used in the controller to create or find users.

---

6️⃣ Token Generator Utility

// utils/token-generator.js

const jwt = require("jsonwebtoken");

const generateToken = (id) => {
  return jwt.sign({ id }, process.env.JWT_SECRET, {
    expiresIn: "1d",
  });
};

module.exports = generateToken;

✅ JWT is used for authentication — it stores user identity securely in cookies so the user stays logged in.

---

🔄 Visual Flow (Simple Diagram)

Browser
  ↓
GET /
  ↓
app.js
  ↓
authRoutes.js → GET / → render("home")
  ↓
Controller (if POST)
  ↓
Model → MongoDB
  ↓
Response sent back to client

---

🧪 GET vs POST — Why Both?

---

🧠 Final Summary

• Every request follows this chain:

  Client → Router → Controller → Model → Response

• Use GET for showing pages and POST for handling form submissions

• Structure your project using MVC for cleaner code

• Always hash passwords and use JWT for authentication

---

🚀 Bonus Tip

When you document your code like this:

• ✅ You understand your code better

• ✅ Others can read and follow it

• ✅ Makes your portfolio stand out

---