As an Express.js application grows, managing all the code in a single file becomes difficult. A well-structured project separates routes, controllers, services, models, middleware, and configuration into different folders, making the application easier to maintain, debug, test, and scale.
First, set up Express.js in your project.
Benefits of a good Structure
- Better Code Organization: Keeps related files in separate folders.
- Easier Maintenance: Makes locating and updating code easier.
- Team Collaboration: Allows multiple developers to work independently.
- Scalability: Supports adding new features without cluttering the project.
Folder Structure Overview
Here’s an advanced and effective folder structure for your Express.js application
The following folder structure is commonly used in Express.js applications. Each folder and file has a specific responsibility, making the application easier to organize, maintain, and scale. Below is an explanation of each folder and file.
1. config/ Folder
This folder holds configuration files related to the database, environment, and other settings.
- dbConfig.js: Contains the configuration for connecting to the database, like the host, username, and password.
module.exports = {
dbUrl: process.env.DB_URL || 'mongodb://localhost:27017/mydb',
};
- Separation of Configurations: Keeps all environment configurations in one place for easier management.
- Environment Flexibility: Allows easy switching of configurations for different environments (development, production).
- Database Configuration: Centralizes database connection settings for better maintainability.
2. controllers/ Folder
Controllers contain the logic for each route, handling requests, processing data, and sending responses. This keeps routes clean and focused on HTTP handling.
exports.getAllUsers = (req, res) => {
res.status(200).json([
{ id: 1, name: "John" },
{ id: 2, name: "Alice" }
]);
};
- Request Handling: Processes incoming HTTP requests.
- Response Handling: Sends the appropriate response back to the client.
- Business Logic: Keeps request-handling logic separate from routes.
3. database/ Folder
This folder contains database connection logic.
- db.js: Creates and exports the database connection.
const mysql = require("mysql");
const connection = mysql.createConnection({
host: "localhost",
user: "root",
password: "",
database: "mydb",
});
connection.connect();
module.exports = connection;
- Database Connection: Creates a connection to the database.
- Reusability: Can be imported wherever database access is required.
- Easy Maintenance: Keeps database logic separate from application code.
4. .env File
Contains environment variables and configurations like API keys, JWT secrets, etc.
- The .env file stores environment-specific variables such as database URLs, API keys, and secret values.
DB_URL=mongodb://localhost:27017/mydb
JWT_SECRET=mysecretkey
- Secure Storage: Keeps sensitive information out of the source code.
- Environment Configuration: Supports different settings for development and production.
- Better Security: Prevents secrets from being hardcoded.
5. middleware/ Folder
Middleware functions are executed during the request-response cycle. They can perform tasks like authentication, logging, or validation before the request reaches the route handler.
module.exports = (req, res, next) => {
const token = req.headers['authorization'];
if (!token) return res.status(403).send('No token provided');
// Check token validity here
next();
};
- Authentication: Middleware is used to secure routes by verifying tokens.
- Reusable Logic: Can be applied to multiple routes to handle common tasks like authentication or logging.
- Flow Control: Uses next() to pass control to the next middleware or route handler.
6. models/ Folder
Models define the structure of your data and interact with the database.
- userModel.js: Defines the structure of user data, such as name and email.
const user = {
id: 1,
name: "John Doe",
email: "john@example.com"
};
module.exports = user;
- Data Structure: Defines how application data is organized.
- Database Interaction: Represents data used by the application.
- Reusability: Can be imported wherever user data is required.
7. public/ Folder
This folder contains static files like HTML, images, and CSS that are served directly to the client.
- index.html: The main HTML page.
- Static Assets: Stores files that are directly accessible to the client without any server-side processing.
- Client-Side Resources: Contains HTML, CSS, and image files for the frontend.
8. routes/ Folder
Routes manage HTTP requests (GET, POST, PUT, DELETE) and map them to controller functions.
- userRoutes.js: Defines the routes for user operations like fetching all users.
const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');
router.get('/users', userController.getAllUsers);
module.exports = router;
- Route Management: Organizes routes based on features or entities (e.g., userRoutes).
- Cleaner Code: Separates the routing logic from the controller logic, keeping files smaller and easier to manage.
9. services/ Folder
exports.getUser = () => {
return {
id: 1,
name: "John Doe"
};
};
- Business Logic: Keeps business logic separate from controllers.
- Reusability: Service functions can be reused across multiple controllers.
- Cleaner Code: Makes controllers smaller and easier to maintain.
10. tests/ Folder
This folder contains automated tests to verify that the application works correctly.
- integration.test.js: Tests how multiple modules work together.
- unit.test.js: Tests individual functions or modules.
11. utils/ Folder
Contains helper functions like logging or error handling that can be reused throughout the app.
- logger.js: A simple logging utility.
module.exports = (message) => {
console.log(`[LOG]: ${message}`);
};
- Reusable Functions: Stores commonly used functions to avoid code duplication.
- Utility Focus: Contains utility functions that enhance code readability and maintainability.
12. views/ Folder
If using a templating engine like EJS or Pug, this folder contains the views (templates) for rendering dynamic HTML on the server-side.
- index.ejs: The main template used to render dynamic HTML content.
- Dynamic Rendering: Allows server-side rendering of dynamic content before sending it to the client.
- Template Reusability: Templates help in reusing HTML code and keeping it DRY (Don’t Repeat Yourself).
13. server.js File
The entry point of the application. It starts the Express server and listens for incoming requests.
const app = require('./app');
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`Server is running on http://localhost:${PORT}`);
});
- Server Setup: Initializes the server and listens for requests.
- App Initialization: Loads the Express app from app.js and starts the server.
14. app.js File
This file contains the core Express application, including middleware, routes, and application settings.
const express = require("express");
const app = express();
app.use(express.json());
module.exports = app;
- Application Setup: Creates the Express application.
- Middleware Registration: Registers middleware used across the application.
- Route Configuration: Loads application routes.
15. package.json File
This file stores project metadata, dependencies, npm scripts, and other project information.
- Project Metadata: Stores the project name, version, and description.
- Dependency Management: Lists all installed packages.
- NPM Scripts: Defines commands such as npm start and npm test.
16. README.md File
This file contains project documentation, including installation steps, usage instructions, and other important information.
- Project Overview: Describes the application.
- Installation Guide: Explains how to set up the project.
- Usage Instructions: Shows how to run and use the application.