Blogify – Blogging Platform Backend

Overview

Blogify is a comprehensive backend API designed to power modern blogging platforms. Built with Node.js and Express.js, it provides a secure and scalable foundation for content management systems.

The project emphasizes security and data integrity, featuring robust user authentication with JWT (JSON Web Tokens) and a structured MongoDB database for storing users, posts, and comments.

Key Features

Security & Auth

• JWT Authentication: Stateless authentication mechanism for secure API access.
• Password Hashing: User passwords are encrypted using bcrypt before storage.
• Role-Based Access Control: Admin and User roles to manage permissions (e.g., only authors can edit their posts).

Content Management

• CRUD Operations: Full Create, Read, Update, Delete support for blog posts.
• Pagination: Efficiently fetch large lists of posts with page and limit parameters.
• Search & Filter: Filter posts by tags, categories, or author.

API Endpoints

Authentication

POST /api/auth/register - Register a new user
POST /api/auth/login    - Login and receive JWT

Blog Posts

GET    /api/posts       - Get all posts (paginated)
GET    /api/posts/:id   - Get single post details
POST   /api/posts       - Create a new post (Auth required)
PUT    /api/posts/:id   - Update a post (Auth required)
DELETE /api/posts/:id   - Delete a post (Auth required)

Technical Implementation

Middleware Architecture

The application uses custom middleware for error handling and authentication verification.

// Auth Middleware
const protect = async (req, res, next) => {
  let token;
  if (req.headers.authorization?.startsWith('Bearer')) {
    try {
      token = req.headers.authorization.split(' ')[1];
      const decoded = jwt.verify(token, process.env.JWT_SECRET);
      req.user = await User.findById(decoded.id).select('-password');
      next();
    } catch (error) {
      res.status(401).json({ message: 'Not authorized' });
    }
  }

  if (!token) {
    res.status(401).json({ message: 'No token, authorization denied' });
  }
};

Data Modeling

Mongoose models define the structure and relationships of the data.

const postSchema = mongoose.Schema({
  user: {
    type: mongoose.Schema.Types.ObjectId,
    required: true,
    ref: 'User',
  },
  title: {
    type: String,
    required: [true, 'Please add a title'],
  },
  content: {
    type: String,
    required: [true, 'Please add content'],
  },
}, {
  timestamps: true,
});

Challenges & Solutions

• Security: Implementing secure authentication from scratch required understanding JWT signing and verification flows. I ensured that tokens are short-lived and sensitive data is never exposed in the payload.
• Error Handling: Creating a centralized error handler middleware helped in maintaining consistent error responses across the entire API, making debugging much easier for frontend developers.