Building a Modular Authentication System in Node.js

nodenextreact

07 November 2024

Creating a scalable backend with Node.js requires organizing your code well, especially as your application grows. For a clean and modular setup, separating models, controllers, routes, and middlewares into their own files is a highly effective approach. In this guide, we'll go through setting up an authentication system in Node.js where we isolate each component and store the schema in a dedicated file.

Project Structure

Organizing the code in a modular way means structuring your files in a way that logically separates each function. Here’s the project structure we’ll be using:

Code

your_project_name/
├── config/
│   └── db.js                  # Database connection file
├── controllers/
│   └── authController.js      # Controller functions for authentication
├── middleware/
│   └── authMiddleware.js      # Middleware for token verification
├── models/
│   └── User.js                # User model that imports the schema
├── schemas/
│   └── userSchema.js          # Separate schema file for User
├── routes/
│   └── authRoutes.js          # Authentication routes
├── .env                       # Environment variables
├── app.js                     # Main app file
├── server.js                  # Server entry point
└── package.json

1. Database Connection

To connect to MongoDB, we’ll start by setting up a db.js file in a config folder. This file will handle connecting to the MongoDB database, making the main application file cleaner.

Code

// config/db.js
const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    await mongoose.connect(process.env.DATABASE_URL, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    console.log('MongoDB connected');
  } catch (error) {
    console.error('Database connection failed:', error.message);
    process.exit(1);
  }
};

module.exports = connectDB;

2. User Schema

In the schemas directory, we create userSchema.js to define the user schema for MongoDB. Separating schemas allows us to organize them in a dedicated folder, making the codebase more readable.

Code

// schemas/userSchema.js
const mongoose = require('mongoose');
const bcrypt = require('bcrypt');

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

// Password hashing middleware
userSchema.pre('save', async function (next) {
  if (!this.isModified('password')) return next();
  this.password = await bcrypt.hash(this.password, 10);
  next();
});

// Password comparison method
userSchema.methods.comparePassword = async function (password) {
  return await bcrypt.compare(password, this.password);
};

module.exports = userSchema;

3. User Model

The User.js file in the models folder imports the userSchema and creates a model with it. This keeps the model and schema modular and maintains separation between model creation and schema definition.

Code

// models/User.js
const mongoose = require('mongoose');
const userSchema = require('../schemas/userSchema');

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

4. Authentication Controller

In the controllers folder, authController.js handles the logic for registering and logging in users. The controller also includes a profile retrieval function, demonstrating how to build APIs around authentication.

Code

// controllers/authController.js
const User = require('../models/User');
const jwt = require('jsonwebtoken');

exports.register = async (req, res) => {
  try {
    const { username, password, email } = req.body;
    const user = new User({ username, password, email });
    await user.save();
    res.status(201).json({ message: 'User registered successfully' });
  } catch (error) {
    res.status(400).json({ message: error.message });
  }
};

exports.login = async (req, res) => {
  try {
    const { username, password } = req.body;
    const user = await User.findOne({ username });
    if (!user || !(await user.comparePassword(password))) {
      return res.status(401).json({ message: 'Invalid credentials' });
    }
    const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '1h' });
    res.json({ message: 'Login successful', token });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

exports.profile = async (req, res) => {
  try {
    const user = await User.findById(req.user.id).select('-password');
    res.json(user);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

5. Authentication Middleware

The authMiddleware.js file in middleware ensures that routes requiring authentication verify the user’s token before granting access.

Code

// middleware/authMiddleware.js
const jwt = require('jsonwebtoken');

exports.authMiddleware = (req, res, next) => {
  const token = req.headers['authorization'];
  if (!token) return res.status(401).json({ message: 'Access denied' });

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(400).json({ message: 'Invalid token' });
  }
};

6. Authentication Routes

The authRoutes.js file in routes defines the endpoints for registration, login, and profile fetching.

Code

// routes/authRoutes.js
const express = require('express');
const { register, login, profile } = require('../controllers/authController');
const { authMiddleware } = require('../middleware/authMiddleware');

const router = express.Router();

router.post('/register', register);
router.post('/login', login);
router.get('/profile', authMiddleware, profile);

module.exports = router;

7. Main Application File

In app.js, we set up the Express app, import routes, and connect to the database, keeping this file clean and focused on application setup.

Code

// app.js
const express = require('express');
const dotenv = require('dotenv');
const connectDB = require('./config/db');
const authRoutes = require('./routes/authRoutes');

dotenv.config();
connectDB();

const app = express();
app.use(express.json());
app.use('/api/auth', authRoutes);

module.exports = app;

8. Server Entry Point

Lastly, the server.js file starts the server, allowing app.js to focus on app configuration.

Code

// server.js
const app = require('./app');
const PORT = process.env.PORT || 5000;

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

9. Environment Variables

Add your secrets to a .env file.

Code

PORT=5000
DATABASE_URL=mongodb://localhost:27017/your_db_name
JWT_SECRET=your_jwt_secret

Testing Your Authentication API

Now, you can test your API using tools like Postman or curl. Here are the endpoints: Register: POST /api/auth/register Body: { "username": "user1", "password": "pass123", "email": "user1@example.com" } Login: POST /api/auth/login Body: { "username": "user1", "password": "pass123" } Response: { "message": "Login successful", "token": "..." } Profile: GET /api/auth/profile Headers: Authorization:

Git Repository for the Project

You can find the full code implementation for the project on GitHub. To clone the repository, simply run the following command in your terminal:

Code

git clone https://github.com/rohitsingh820924/nodejs-backend.git