Nodejs Capstone Project Restful Api With Authentication And Database Complete Guide

NodeJS Capstone Project: RESTful API with Authentication and Database

Project Overview

Your Capstone Project will involve creating a RESTful API using Node.js and Express.js frameworks, implementing JWT (JSON Web Token) for authentication, and integrating a database (e.g., MongoDB, PostgreSQL) to store data persistently.

Environment Setup

1. Node.js Installation: Begin by installing Node.js and npm (Node Package Manager) if not already installed, via the official Node.js website.

   # Check Node.js and npm installation
   node -v
   npm -v
   

2. Project Initialization: Create a new project directory and initialize it using npm, creating a package.json file.

   mkdir nodejs-capstone
   cd nodejs-capstone
   npm init -y
   

3. Install Key Packages: Install Express, Mongoose (for MongoDB), or Sequelize (for PostgreSQL), bcrypt for password hashing, and jsonwebtoken for JWT generation and verification.

   npm install express mongoose bcryptjs jsonwebtoken
   

Database Integration

Choosing the right database is crucial for the application’s efficiency and scalability. Here, MongoDB and PostgreSQL will be considered for integration using Mongoose and Sequelize respectively.

1. MongoDB:

   • Install MongoDB: You can download MongoDB from the official website or use a cloud-based solution like MongoDB Atlas.

   • Connect MongoDB to Node.js: Use Mongoose to connect to MongoDB and define schemas.

     const mongoose = require('mongoose');
     mongoose.connect('mongodb://localhost:27017/databaseName', { useNewUrlParser: true, useUnifiedTopology: true })
       .then(() => console.log('MongoDB connected'))
       .catch(err => console.log(err));
     

2. PostgreSQL:

   • Install PostgreSQL: Install PostgreSQL on your system and create a new database.

   • Connect PostgreSQL to Node.js: Use Sequelize to connect to PostgreSQL and model your database schema.

     const Sequelize = require('sequelize');
     const sequelize = new Sequelize('database', 'username', 'password', {
       host: 'localhost',
       dialect: 'postgres',
     });
     
     sequelize.authenticate()
       .then(() => console.log('PostgreSQL connected'))
       .catch(err => console.log(err));
     

Building RESTful API Endpoints

Create CRUD operations along with user authentication endpoints.

1. Middleware: Set up necessary middleware for parsing JSON and handling CORS.

   const express = require('express');
   const app = express();
   app.use(express.json());
   

2. User Authentication Routes: Create routes for user registration, login, and token generation.

   • Register Route: User registration involves creating a new user, hashing the password for storage, and sending confirmation.

     const bcrypt = require('bcryptjs');
     const jwt = require('jsonwebtoken');
     const User = require('./models/User');
     
     app.post('/register', async (req, res) => {
       try {
         let { username, email, password } = req.body;
         let user = await User.findOne({ email });
         if (user) return res.status(400).send('User already exists');
     
         const salt = await bcrypt.genSalt(10);
         password = await bcrypt.hash(password, salt);
     
         user = new User({
           username,
           email,
           password,
         });
     
         await user.save();
         res.send('User registered');
       } catch (error) {
         console.error(error);
         res.status(500).send('Server error');
       }
     });
     

   • Login Route: User login verifies the credentials and returns a JWT.

     app.post('/login', async (req, res) => {
       try {
         let { email, password } = req.body;
         let user = await User.findOne({ email });
         if (!user) return res.status(400).send('Invalid credentials');
     
         const isMatch = await bcrypt.compare(password, user.password);
         if (!isMatch) return res.status(400).send('Invalid credentials');
     
         const payload = { user: { id: user.id } };
         jwt.sign(payload, 'secret', { expiresIn: '1h' }, (err, token) => {
           if (err) throw err;
           res.json({ token });
         });
       } catch (error) {
         console.error(error);
         res.status(500).send('Server error');
       }
     });
     

3. Protected Routes: Protect specific routes requiring authentication by verifying JWTs in request headers.

   const auth = require('./middleware/auth');
   
   app.get('/dashboard', auth, (req, res) => {
     // Authenticated user will access this endpoint
     res.send('You are authorized');
   });
   

Middleware for Authentication

Create a custom middleware to verify JWTs and attach user information to the request object.

const jwt = require('jsonwebtoken');

module.exports = function (req, res, next) {
  const token = req.header('x-auth-token');
  if (!token) return res.status(401).send('Access denied');

  try {
    const decoded = jwt.verify(token, 'secret');
    req.user = decoded.user;
    next();
  } catch (error) {
    res.status(400).send('Invalid token');
  }
};

Complete Application Structure

nodejs-capstone/
│
├── controllers/
│   └── userController.js
│
├── models/
│   └── User.js
│
├── middleware/
│   └── auth.js
│
├── routes/
│   └── userRoutes.js
│
├── app.js
└── package.json

• app.js: Main entry point of application.
• routes/userRoutes.js: Handles all endpoints related to users.
• controllers/userController.js: Contains logic for CRUD operations and authentication.
• models/User.js: Define the User schema using Mongoose or Sequelize.
• middleware/auth.js: Custom authentication middleware to protect routes.

Testing the API

Utilize tools like Postman or curl to test API endpoints for registration, login, and accessing protected routes. Ensure that each endpoint behaves as expected and that authentication works seamlessly.

Error Handling

Implement robust error handling to manage edge cases and send meaningful error messages to the client.

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

Deployment

After testing, deploy your application to a platform like Heroku, AWS, or Vercel for better accessibility and reliability.

Conclusion

This Node.js Capstone Project offers a comprehensive look into building a scalable and secure RESTful API with robust authentication mechanisms. By following the steps outlined in this guide and capitalizing on the best practices specified, you'll be well on your way to mastering back-end development with Node.js. Remember to keep the project modular, maintainable, and reusable, and always aim to write clean, concise code.

Additional Resources

• Node.js Official Documentation
• Express.js Guide
• Mongoose Documentation
• Sequelize Documentation
• JWT.io