Express.js Architecture Overview

Introduction to Express.js

Express.js is a minimal, flexible Node.js web application framework that provides a robust set of features for web and mobile applications. It's the most popular web framework for Node.js and has become the de facto standard for building web applications and APIs with Node.js.

Core Features and Philosophy

Express embraces a minimalist philosophy, focusing on providing only essential features while allowing developers to add functionality through middleware. This approach promotes flexibility and prevents the framework from becoming bloated.

Key Features

• Routing: Define application endpoints and HTTP methods
• Middleware: Process requests through a chain of functions
• Template Engines: Render dynamic HTML using various templating libraries
• Error Handling: Centralized error processing mechanisms
• Static File Serving: Efficiently serve static assets
• HTTP Utility Methods: Simplified HTTP response handling

Express.js Architecture

Express follows a modular architecture that consists of several key components working together.

Request-Response Cycle

The heart of Express is its request-response cycle:

1. A client sends an HTTP request to the Express server
2. Express receives the request and creates request and response objects
3. The request passes through a series of middleware functions
4. The appropriate route handler processes the request
5. The route handler sends a response back to the client

Express Application Object

The Express application object is the main component that:

• Configures middleware
• Defines routes
• Starts the HTTP server
• Handles errors
• Manages other application settings

// Import the express module
const express = require('express');

// Create an Express application
const app = express();

// Define a route
app.get('/', (req, res) => {
    res.send('Hello World!');
});

// Start the server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});
                

Layered Architecture Pattern

While Express itself is minimal, most Express applications follow a layered architecture pattern for better organization and separation of concerns.

• Routes Layer: Defines endpoints and HTTP methods, delegates to controllers
• Controllers Layer: Processes HTTP requests/responses, calls services for business logic
• Services Layer: Contains business logic, coordinates between multiple data sources
• Data Access Layer: Handles database interactions and data operations

project-root/
  ├── node_modules/
  ├── public/           # Static files (CSS, images, client-side JS)
  ├── src/              # Application source code
  │   ├── config/       # Configuration files
  │   ├── controllers/  # Route handlers
  │   ├── middleware/   # Custom middleware
  │   ├── models/       # Data models
  │   ├── routes/       # Route definitions
  │   ├── services/     # Business logic
  │   ├── utils/        # Utility functions
  │   └── app.js        # Express application setup
  ├── tests/            # Test files
  ├── .env              # Environment variables
  ├── .gitignore
  ├── package.json
  └── README.md
                

Middleware Architecture

Middleware is a fundamental concept in Express.js. It consists of functions that have access to the request object, the response object, and the next middleware function in the application's request-response cycle.

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

// Middleware function 1: Logger
app.use((req, res, next) => {
    console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
    next(); // Pass control to the next middleware
});

// Middleware function 2: Request time tracker
app.use((req, res, next) => {
    req.requestTime = Date.now();
    next();
});

// Route with middleware function 3: Authentication check
app.get('/protected', 
    (req, res, next) => {
        // Check if user is authenticated
        const isAuthenticated = req.query.token === 'secret';
        if (!isAuthenticated) {
            return res.status(401).send('Unauthorized');
        }
        next();
    },
    (req, res) => {
        // This is the route handler (final step)
        const responseTime = Date.now() - req.requestTime;
        res.send(`Protected content accessed. Response time: ${responseTime}ms`);
    }
);

// Basic route
app.get('/', (req, res) => {
    const responseTime = Date.now() - req.requestTime;
    res.send(`Hello World! Response time: ${responseTime}ms`);
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});
                

Common Types of Express Middleware

Express middleware can be categorized based on their purposes and scope:

Application-level Middleware

Bound to the app object using app.use() or app.METHOD(). These execute for all routes or specific routes.

// Application-level middleware for all routes
app.use((req, res, next) => {
    console.log('Time:', Date.now());
    next();
});

// Application-level middleware for specific path
app.use('/user', (req, res, next) => {
    console.log('Request Type:', req.method);
    next();
});
            

Router-level Middleware

Bound to an instance of express.Router(). These work like application-level middleware but are limited to the router instance.

const router = express.Router();

router.use((req, res, next) => {
    console.log('Router-specific middleware');
    next();
});

router.get('/user', (req, res) => {
    res.send('User page');
});

app.use('/', router);
            

Error-handling Middleware

Takes four arguments (err, req, res, next) and handles errors that occur in the middleware chain.

app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('Something broke!');
});
            

Built-in Middleware

Express includes a few built-in middleware functions:

• express.static: Serves static assets
• express.json: Parses incoming requests with JSON payloads
• express.urlencoded: Parses incoming requests with URL-encoded payloads

// Serve static files from 'public' directory
app.use(express.static('public'));

// Parse JSON request bodies
app.use(express.json());

// Parse URL-encoded request bodies
app.use(express.urlencoded({ extended: true }));
            

Third-party Middleware

External middleware packages that add functionality to Express applications:

• morgan: HTTP request logger
• helmet: Helps secure Express apps by setting HTTP headers
• cors: Enables Cross-Origin Resource Sharing
• compression: Compresses response bodies

const morgan = require('morgan');
const helmet = require('helmet');
const cors = require('cors');
const compression = require('compression');

app.use(morgan('dev'));
app.use(helmet());
app.use(cors());
app.use(compression());
            

Express vs Other Node.js Frameworks

Express.js is one of many Node.js frameworks, each with its own strengths and weaknesses:

Express.js Use Cases

Express.js is versatile and can be used in various scenarios:

RESTful APIs

Express excels at building RESTful APIs due to its routing capabilities and middleware system.

// Simple REST API example
const express = require('express');
const app = express();
app.use(express.json());

let users = [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' }
];

// GET all users
app.get('/api/users', (req, res) => {
    res.json(users);
});

// GET a single user
app.get('/api/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    if (!user) return res.status(404).send('User not found');
    res.json(user);
});

// POST a new user
app.post('/api/users', (req, res) => {
    const user = {
        id: users.length + 1,
        name: req.body.name
    };
    users.push(user);
    res.status(201).json(user);
});

app.listen(3000);
            

Server-rendered Web Applications

With template engines, Express can render dynamic HTML pages on the server.

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

// Set up EJS as the view engine
app.set('view engine', 'ejs');
app.set('views', './views');

// Serve static files
app.use(express.static('public'));

// Route that renders a template
app.get('/profile/:username', (req, res) => {
    // In a real app, you'd fetch this data from a database
    const userData = {
        username: req.params.username,
        bio: 'Lorem ipsum dolor sit amet',
        joinDate: '2023-01-15',
        posts: ['Post 1', 'Post 2', 'Post 3']
    };
    
    res.render('profile', userData);
});

app.listen(3000);
            

Real-time Applications

Combined with Socket.IO, Express can power real-time applications like chat systems or live dashboards.

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

app.use(express.static('public'));

app.get('/', (req, res) => {
    res.sendFile(__dirname + '/public/index.html');
});

// Socket.IO connection handling
io.on('connection', (socket) => {
    console.log('A user connected');
    
    socket.on('chat message', (msg) => {
        io.emit('chat message', msg); // Broadcast to all connected clients
    });
    
    socket.on('disconnect', () => {
        console.log('A user disconnected');
    });
});

server.listen(3000, () => {
    console.log('Server running on port 3000');
});
            

Microservices

Express is lightweight enough to be used in microservice architectures, where each service is a small, focused Express application.

// user-service.js
const express = require('express');
const app = express();
app.use(express.json());

app.get('/users', async (req, res) => {
    // Get users from database
    const users = await db.collection('users').find().toArray();
    res.json(users);
});

app.listen(3001, () => {
    console.log('User service running on port 3001');
});

// product-service.js
const express = require('express');
const app = express();
app.use(express.json());

app.get('/products', async (req, res) => {
    // Get products from database
    const products = await db.collection('products').find().toArray();
    res.json(products);
});

app.listen(3002, () => {
    console.log('Product service running on port 3002');
});
            

Practical Exercises

Try these exercises to practice and reinforce your understanding of Express.js architecture:

Further Resources

• Express.js Official Documentation
• Express.js GitHub Repository
• Express.js Tutorial on TutorialsPoint
• MDN Express/Node.js Tutorial
• Node.js, Express, MongoDB Bootcamp