Backend development using MERN

Are you ready to take your blog website to the next level? In this guide, I'll walk you through the process of building a powerful backend for your blog website. From user authentication to blog post management, I'll cover all the essential features that make your website functional and secure. By the end of this tutorial, you'll have a fully functional backend implemented using Node.js, Express, MongoDB, and other popular npm packages. So, let's dive in and bring your blog website to life!

NPM Packages

To build a robust backend for your blog website, we'll leverage the power of various npm packages. Here are some key packages we'll be using and their significance:

Express: Express is a fast and minimalist web application framework for Node.js. It simplifies the process of building APIs, handling routes, and managing middleware.
Mongoose: Mongoose is an elegant MongoDB object modeling tool. It provides a straightforward way to define schemas, perform database operations, and interact with MongoDB.
Bcrypt: Bcrypt is a popular package for hashing and salting passwords. It ensures that user passwords are securely stored in the database.
JsonWebToken: JsonWebToken (JWT) is a package for generating and verifying JSON web tokens. It enables secure user authentication and authorization.

Project Directory Structure

To maintain a well-organized codebase, let's define the project directory structure:

├── app.js
├── routes/
│   └── user.js
│   └── blog.js
├── models/
│   └── user.js
│   └── blog.js
├── middleware/
│   └── authMiddleware.js
├── config/
│   └── config.js
├── package.json
└── node_modules/

In this structure, the app.js file serves as the main entry point, while the routes/, models/, middleware/, and config/ directories house the respective files for handling routes, defining data models, implementing middleware, and managing configurations. The package.json file manages our project dependencies and the node_modules/ directory stores the installed npm packages.

Implementation Steps

Step 1: Set up the project and install dependencies:

mkdir blog-backend
cd blog-backend
npm init -y
npm install express mongoose bcrypt jsonwebtoken

Step 2: Create the user model:

// models/user.js
const mongoose = require("mongoose");

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

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

Step 3: Create blog model:

const mongoose = require("mongoose");

const blogSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true,
  },
  content: {
    type: String,
    required: true,
  },
  user: {
    type: mongoose.Schema.Types.ObjectId,
    ref: "User",
    required: true,
  },
});

const Blog = mongoose.model("Blog", blogSchema);

module.exports = Blog;

Step 4: Implement user signup:

// routes/user.js
const express = require("express");
const router = express.Router();
const bcrypt = require("bcrypt");
const User = require("../models/user");

router.post("/signup", async (req, res) => {
  try {
    const { username, password, email } = req.body;

    // Hash the password
    const hashedPassword = await bcrypt.hash(password, 10);

    // Create a new user
    const user = new User({
      username,
      password: hashedPassword,
      email,
    });

    // Save the user to the database
    await user.save();

    res.status(201).json({ message: "User registered successfully" });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

module.exports = router;

Step 5: Implement user login:

// routes/user.js
router.post("/login", async (req, res) => {
  try {
    const { username, password } = req.body;

    // Find the user by username
    const user = await User.findOne({ username });

    // Check if the user exists
    if (!user) {
      return res.status(404).json({ message: "User not found" });
    }

    // Compare the provided password with the stored password
    const isPasswordValid = await bcrypt.compare(password, user.password);

    if (!isPasswordValid) {
      return res.status(401).json({ message: "Invalid password" });
    }

    // Generate a JSON web token (JWT)
    const token = generateToken(user);

    res.json({ token });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

// Helper function to generate JWT
function generateToken(user) {
  // Generate and return the JWT
}

Step 6: Implement blog creation:

// routes/blog.js
const express = require("express");
const router = express.Router();
const authMiddleware = require("../middleware/authMiddleware");
const Blog = require("../models/blog");

router.post("/", authMiddleware, async (req, res) => {
  try {
    const { title, content } = req.body;

    // Create a new blog post
    const blog = new Blog({
      title,
      content,
      user: req.user._id,
    });

    await blog.save();

    res.status(201).json({ message: "Blog created successfully" });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

Step 7: Implement blog retrieval route

Continue editing the routes/blog.js file and add the following code:

// routes/blog.js
// ...

router.get('/', authMiddleware, async (req, res) => {
  try {
    const userId = req.user._id;

    // Find all blogs for the authenticated user
    const blogs = await Blog.find({ user: userId });

    res.status(200).json({ blogs });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

// ...

Step 8: Implement blog update route

Continue editing the routes/blog.js file and add the following code:

// routes/blog.js
// ...

router.put('/:id', authMiddleware, async (req, res) => {
  try {
    const blogId = req.params.id;
    const userId = req.user._id;
    const { title, content } = req.body;

    // Find the blog by ID and ensure it belongs to the authenticated user
    const blog = await Blog.findOne({ _id: blogId, user: userId });

    if (!blog) {
      return res.status(404).json({ message: 'Blog not found' });
    }

    // Update the blog
    blog.title = title;
    blog.content = content;
    await blog.save();

    res.json({ message: 'Blog updated successfully', blog });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

// ...

Step 9: Implement blog deletion route

Continue editing the routes/blog.js file and add the following code:

// routes/blog.js
// ...

router.delete('/:id', authMiddleware, async (req, res) => {
  try {
    const blogId = req.params.id;
    const userId = req.user._id;

    // Find the blog by ID and ensure it belongs to the authenticated user
    const blog = await Blog.findOne({ _id: blogId, user: userId });

    if (!blog) {
      return res.status(404).json({ message: 'Blog not found' });
    }

    // Delete the blog
    await blog.remove();

    res.json({ message: 'Blog deleted successfully' });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

That's it! You've now implemented all the CRUD operations for managing blog posts. The backend for your blog website is now ready to handle user registration, authentication, and blog management.

Testing the APIs using Postman

Now that you have implemented the backend for your blog website, it's time to test the API endpoints using Postman. Postman is a popular API testing tool that allows you to send HTTP requests and inspect the responses.

Open Postman and create a new request collection for your blog API.
Set the base URL for your API requests as http://localhost:3000 or the appropriate URL where your server is running.
Let's start by testing the user registration and authentication flow.

User Registration
- Send a POST request to /user/signup with the following JSON body:
```
  {
    "username": "testuser",
    "password": "testpass",
    "email": "testuser@example.com"
  }
```
- You should receive a 201 Created response with the user information and a token in the response body.

User Login

Send a POST request to /user/login with the following JSON body:

  {
    "username": "testuser",
    "password": "testpass"
  }

You should receive a 200 OK response with the user information and a token in the response body.
Copy the token as you will need it for authenticated requests.

With the token, you can now test the blog-related endpoints.

Create a Blog
- Send a POST request to /blog with the following JSON body:
```
  {
    "title": "Sample Blog Title",
    "content": "Sample blog content..."
  }
```
- Make sure to include the Authorization header with the value Bearer <token>, replacing <token> with the copied token from the login response.
- You should receive a 201 Created response with the created blog information in the response body.

Get All Blogs

Send a GET request to /blog with the Authorization header.
You should receive a 200 OK response with an array of all blogs associated with the authenticated user.

Get a Specific Blog

Send a GET request to /blog/{blogId}, replacing {blogId} with the ID of a specific blog.
You should receive a 200 OK response with the blog information in the response body.

Update a Blog

Send a PUT request to /blog/{blogId}, replacing {blogId} with the ID of the blog you want to update.

Include the updated blog information in the JSON body, for example:

  {
    "title": "Updated Blog Title",
    "content": "Updated blog content..."
  }

You should receive a 200 OK response with the updated blog information in the response body.

Delete a Blog

Send a DELETE request to /blog/{blogId}, replacing {blogId} with the ID of the blog you want to delete.
You should receive a 200 OK response with a message indicating successful deletion.

Feel free to experiment with different requests, test edge cases, and explore other API functionalities.

Congratulations! You have successfully tested the API endpoints using Postman. Make sure to include these steps in your Postman testing section of the blog post to provide a detailed guide for API testing.

Conclusion

We have successfully built a robust backend for our blog website using Node.js, Express, and MongoDB. With user authentication and CRUD operations for blogs, our application is ready to handle user registrations, login sessions, and efficient management of blog content.

Postman was instrumental in testing our API endpoints and ensuring their functionality.

If you have any questions or need assistance, please don't hesitate to reach out to me on LinkedIn. Happy coding! 🙂

Building a Robust Backend for Your Blog Website

Table of contents

NPM Packages

Project Directory Structure

Implementation Steps

Testing the APIs using Postman

Conclusion