Kodenique-Nodejs-Project-Structure.md

🏗 ** Node.js Express Project Structure**

/project-root
│── /src
│   ├── /config           # Configuration files (DB, env, etc.)
│   │   ├── db.config.js
│   │   ├── env.config.js
│   │   ├── logger.config.js
│   ├── /loaders          # Application bootstrapping (DB, Express, etc.)
│   │   ├── express.js
│   │   ├── database.js
│   │   ├── security.js
│   │   ├── routes.js
│   ├── /models
│   │   ├── users.ts
│   ├── /modules          # Feature-based modular services
│   │   ├── /auth
│   │   │   ├── auth.controller.js
│   │   │   ├── auth.service.js
│   │   │   ├── auth.routes.js
│   │   │   ├── auth.middleware.js
│   │   ├── /user
│   │   │   ├── user.controller.js
│   │   │   ├── user.service.js
│   │   │   ├── user.routes.js
│   │   │   ├── user.middleware.js
│   │   ├── /order
│   │   │   ├── order.controller.js
│   │   │   ├── order.service.js
│   │   │   ├── order.routes.js
│   │   │   ├── order.middleware.js
│   ├── /middlewares      # Global middlewares
│   │   ├── auth.middleware.js
│   │   ├── error.middleware.js
│   │   ├── validation.middleware.js
│   ├── /shared           # Reusable utilities/helpers
│   │   ├── jwt.helper.js
│   │   ├── logger.helper.js
│   │   ├── apiResponse.js
│   ├── /database         # Database connections and migrations
│   │   ├── migrations/
│   │   ├── seeders/
│   │   ├── connection.js
│   ├── /tests            # Unit & integration tests
│   │   ├── auth.test.js
│   │   ├── user.test.js
│   ├── app.js            # App initialization
│   ├── server.js         # Server entry point
│── /public               # Static files
│── /views                # Templating engine views (if applicable)
│── .env                  # Environment variables
│── .gitignore            # Git ignore file
│── package.json          # Project metadata & dependencies
│── README.md             # Documentation

---

🔥 Why This Structure?

This architecture mimics a framework and allows scalability like a full-fledged system.

🏗 Key Concepts

1. /config → Centralized configuration files.
2. /loaders → Handles Express, database, security, etc., ensuring modular startup.
3. /modules (Feature-Based Structure)
   • Each module (Auth, User, Order) is self-contained.
   • Contains:
     • controller.js → Handles HTTP requests.
     • service.js → Business logic layer.
     • routes.js → Defines Express routes.
     • model.js → Database schema/model.
     • middleware.js → Module-specific middleware.
4. /middlewares → Global middlewares like authentication and validation.
5. /shared → Reusable helpers (e.g., JWT, logging, API response formatting).
6. /database → Handles database connection, migrations, and seeders.
7. /tests → Organized test structure for unit/integration testing.
8. server.js → Starts the application.

---

🚀 Example Usage

📌 server.js

const express = require("express");
const loaders = require("./src/loaders/express");
const database = require("./src/loaders/database");

async function startServer() {
  await database.connect(); // Initialize DB
  const app = express();
  loaders(app); // Initialize middlewares, routes, etc.
  
  const PORT = process.env.PORT || 5000;
  app.listen(PORT, () => console.log(`🚀 Server running on port ${PORT}`));
}

startServer();

---

📌 src/loaders/express.js

const express = require("express");
const cors = require("cors");
const helmet = require("helmet");
const morgan = require("morgan");
const authRoutes = require("../modules/auth/auth.routes");
const userRoutes = require("../modules/user/user.routes");

module.exports = (app) => {
  app.use(cors());
  app.use(helmet());
  app.use(morgan("dev"));
  app.use(express.json());

  // Register routes
  app.use("/api/auth", authRoutes);
  app.use("/api/users", userRoutes);
};

---

📌 src/modules/auth/auth.controller.js

const AuthService = require("./auth.service");

exports.login = async (req, res, next) => {
  try {
    const { email, password } = req.body;
    const token = await AuthService.authenticate(email, password);
    res.status(200).json({ success: true, token });
  } catch (error) {
    next(error);
  }
};

---

📌 src/modules/auth/auth.service.js

const UserModel = require("../user/user.model");
const jwtHelper = require("../../shared/jwt.helper");

exports.authenticate = async (email, password) => {
  const user = await UserModel.findOne({ email });
  if (!user || user.password !== password) throw new Error("Invalid credentials");
  return jwtHelper.generateToken(user);
};

routes.js

fs.readdirSync(__dirname).forEach((file) => {
    if (file !== "index.js" && file.endsWith(".routes.js")) {
      const route = require(path.join(__dirname, file));
      app.use("/api", route);
    }
  });

---

🏆 Benefits of This Structure

✅ Modular & Scalable – Feature-based architecture for large applications.
✅ Separation of Concerns – Clear division between routes, controllers, and services.
✅ Easy to Maintain – Each module is self-contained and easy to extend.
✅ Security & Performance – Uses helmet, cors, and morgan.
✅ Database Flexibility – Supports MongoDB (Mongoose) or SQL (Sequelize/TypeORM).
✅ Testing-Ready – Structured for easy unit/integration testing.

---