Forem: Prathviraj H

Using Multiple GitHub Accounts

Prathviraj H — Fri, 06 Feb 2026 16:43:12 +0000

When I started working with multiple GitHub accounts on the same laptop, I was confused about how authentication actually works. I used to think GitHub checks my email or username when I push code, but I learned that GitHub mainly identifies me using SSH keys.

SSH is a secure way for my computer to prove its identity to GitHub. Instead of typing a username and password every time, my laptop shows a digital identity in the form of a key. This makes pushing and pulling code faster and safer.

I learned that SSH always comes in pairs: a public key and a private key. The public key is shared with GitHub, and the private key stays only on my laptop. GitHub keeps the public key, and when I try to connect, my laptop proves it owns the matching private key. If they match, access is granted.

An important concept I understood is that the private key must never be shared with anyone. Only the public key is meant to be copied and added to GitHub.

I also learned about the SSH agent. The SSH agent is a background helper that remembers which private keys are available on my system. Because of the agent, I do not have to re-enter passphrases every time I use Git. It acts like a key holder that temporarily stores my keys in memory.

Another big learning was about the SSH configuration file. This file allows me to define multiple identities on the same machine. I can give each GitHub account a nickname and map that nickname to a specific private key. This means I can tell my system which key should be used for which account.

Because of this setup, I now understand that Git decides which GitHub account to use based on the repository’s remote address. The remote address contains a host alias, and that alias points to a specific key in the SSH configuration file. So the remote URL indirectly controls which GitHub account is used.

I also learned that commit email and GitHub authentication are two different things. The email written in a commit only affects how the commit appears in history. It does not decide which GitHub account is pushing the code. The actual account is decided only by the SSH key being used.

Another useful concept I understood is that Git configuration exists at two levels: global and local. Global configuration applies to all repositories on my system. Local configuration applies only to one specific project. This allows me to use my own email for my projects and my friend’s email only inside my friend’s repository.

I learned how to check which keys are currently loaded in the SSH agent and how to remove or re-add them. This helped me understand that multiple keys can exist at the same time, and Git will choose the correct one based on configuration and remote URL.

Overall, I now clearly understand that SSH keys control who I authenticate as, remote URLs decide which key is used, and commit email only controls how my name appears in history. This knowledge allows me to safely work with multiple GitHub accounts on the same laptop without conflicts.

Understanding REST APIs and Best Practices (With CampusX Implementation)

Prathviraj H — Sun, 16 Mar 2025 09:33:26 +0000

What is a REST API?

A REST API (Representational State Transfer API) is a way for different systems to communicate over HTTP using standard methods like GET, POST, PUT, DELETE. It follows principles that make it scalable, stateless, and easy to integrate.

Key Features of REST APIs:

Stateless – Each request from a client contains all necessary information, and the server doesn’t store session data.
Client-Server Architecture – The client and server operate independently, improving scalability.
Resource-Based – Data is treated as resources (e.g., /users, /posts).
Use of HTTP Methods – Follows standard methods:
- GET – Retrieve data
- POST – Create a resource
- PUT/PATCH – Update a resource
- DELETE – Remove a resource
JSON as Response Format – Mostly uses JSON for structured data exchange.
Stateless Authentication – Uses tokens like JWT or OAuth.

Best Practices for Designing REST APIs

1. Use Meaningful Resource Names

Instead of /getUserDetails?id=123, use /users/123.

2. Follow HTTP Methods Correctly

GET /users → Fetch all users
POST /users → Create a new user
PUT /users/123 → Update user with ID 123
DELETE /users/123 → Remove user with ID 123

3. Use Status Codes Properly

200 OK → Success
201 Created → Resource Created
400 Bad Request → Invalid Input
401 Unauthorized → Authentication Required
404 Not Found → Resource Doesn’t Exist
500 Internal Server Error → Unexpected Issue

4. Paginate Large Results

For large datasets, use pagination:

GET /posts?page=2&limit=10

5. Secure APIs with Authentication

Use JWT (JSON Web Tokens) for authentication.
Implement rate limiting to prevent abuse.
Use HTTPS to encrypt communication.

6. Implement Versioning

APIs evolve over time, so version them:

GET /v1/users
GET /v2/users

7. Use Consistent Error Handling

Standard error responses help debugging. Example:

{
  "error": {
    "code": 400,
    "message": "Invalid input",
    "details": "Email field is required"
  }
}

How REST APIs Are Used in CampusX

1. User Authentication (JWT)

CampusX uses JWT-based authentication:

POST /register → Registers a new user with profile images.
POST /login → Logs in a user, returns JWT token.
POST /logout → Logs out a user.
POST /refresh-token → Refreshes access token.
POST /change-password → Changes the current password.
GET /current-user → Fetches authenticated user details.

2. Post Management

Users can create and manage posts related to VTU exams, placements, college clubs, etc.:

POST / → Creates a new post (Authenticated users only, with image upload).
GET / → Fetches all posts.
GET /:id → Fetches a specific post.
DELETE /:id → Deletes a post (Only by the author).

3. Comments & Engagements

Users can engage through comments:

POST /:postId/comments → Adds a comment.
GET /:postId/comments → Fetches comments.
DELETE /:postId/comments/:commentId → Deletes a comment.

4. User Profile & Account Management

Users can update their profiles:

GET /channel/:user → Fetches a user’s profile.
PATCH /update-account → Updates account details.
PATCH /update-avatar → Updates profile avatar.
PATCH /update-coverimage → Updates cover image.
DELETE /delete-account → Deletes a user account.

5. Bookmark & Follow System

Users can bookmark posts and follow/unfollow others:

POST /:postId → Bookmark a post.
DELETE /:bookmarkId → Remove a bookmark.
GET / → Get user bookmarks.
POST /:userId/follow → Follow a user.
POST /:userId/unfollow → Unfollow a user.

Conclusion

REST APIs power CampusX, making it a scalable and flexible college-specific discussion platform. By following REST API best practices, we ensure clean, maintainable, and secure APIs.

Have questions? Drop them in the comments!

Efficient File Uploads in CampusX with Multer

Prathviraj H — Fri, 14 Mar 2025 15:09:02 +0000

CampusX handles file uploads efficiently using Multer, a middleware for handling multipart/form-data. This is essential for managing profile pictures, post images, and other media assets that users upload.

Why Multer?

Efficient Processing: Multer processes files on the server before storing or passing them to a cloud service (e.g., Cloudinary).
Custom Storage Handling: Files are temporarily stored in ./public/temp before being uploaded to Cloudinary for optimized delivery.
Security & Control: Limits the type and size of files, reducing unnecessary server load.

How Multer Works in CampusX

import multer from "multer";

const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, "./public/temp");
  },
  filename: function (req, file, cb) {
    const uniqueSuffix = Date.now() + "-" + Math.round(Math.random() * 1e9);
    cb(null, file.fieldname + "-" + uniqueSuffix);
  },
});

export const upload = multer({
  storage,
});

Temporary Storage: Files are first stored locally in ./public/temp.
Unique Naming: Prevents filename collisions by appending a timestamp and random number.
Integration with Cloudinary: Once uploaded, files are transferred to Cloudinary, and the temporary file is deleted.

Usage in CampusX

When users upload an avatar, post image, or cover image, Multer handles the initial processing.
The file is then uploaded to Cloudinary using the uploadOnCloudinary function.
After upload completion, the local temporary file is deleted.

By using Multer efficiently, CampusX ensures smooth file uploads while offloading long-term storage to Cloudinary, reducing server load and improving performance.

Optimizing Image Management in CampusX with Cloudinary

Prathviraj H — Fri, 14 Mar 2025 15:03:51 +0000

Why Cloudinary?

Cloudinary is a powerful cloud-based image and video management service that enables developers to store, optimize, and deliver media files efficiently. By leveraging Cloudinary, CampusX significantly reduces the load time of images, ensuring a seamless user experience. Instead of storing images on local servers, which can slow down performance and consume storage, Cloudinary serves optimized images via a CDN, reducing latency and bandwidth consumption.

Key Benefits of Using Cloudinary in CampusX

Efficient Storage & Delivery: Images are stored in Cloudinary’s cloud storage and served via their CDN, improving load times.
On-the-Fly Optimization: Cloudinary automatically compresses and resizes images without sacrificing quality, ensuring faster page loads.
Automated Deletion & Updates: Cloudinary's API allows dynamic updates and deletions, ensuring that old images do not remain stored unnecessarily.
Secure & Scalable: Authentication and API security ensure that images are accessible only by authorized users.

Cloudinary Setup in CampusX

To integrate Cloudinary, we configure it using environment variables:

import { v2 as cloudinary } from "cloudinary";

cloudinary.config({
  cloud_name: process.env.CLOUDNARY_CLOUD_NAME,
  api_key: process.env.CLOUDNARY_APIKEY,
  api_secret: process.env.CLOUDNARY_SECRET,
});

This setup ensures that our credentials remain secure and are not hardcoded into the source code.

Uploading Images to Cloudinary

Whenever a user uploads an avatar, cover image, or post image, the image is sent to Cloudinary’s storage, and the response contains a URL for accessing the uploaded image.

const uploadOnCloudnary = async (localfilepath) => {
  try {
    if (!localfilepath) {
      return null;
    }

    const response = await cloudinary.uploader.upload(localfilepath, {
      resource_type: "auto",
      folder: "home/learnDummy",
    });

    console.info("File uploaded :", response.url);
    return response;
  } catch (error) {
    console.log("Error while uploading to Cloudinary");
    fs.unlinkSync(localfilepath);
  }
};

Updating User Avatars & Cover Images

When a user updates their avatar or cover image, the old one is deleted from Cloudinary before uploading the new one, preventing redundant storage.

const updateAvatar = async (oldCloudinaryUrl, localFilePath) => {
  try {
    if (!localFilePath) {
      return null;
    }

    const publicId = oldCloudinaryUrl?.split("/").pop().split(".")[0] || null;

    if (publicId) {
      await cloudinary.uploader.destroy(`home/learnDummy/${publicId}`);
      console.info("Old avatar deleted:", publicId);
    }

    const response = await cloudinary.uploader.upload(localFilePath, {
      resource_type: "auto",
      folder: "home/learnDummy",
    });

    console.info("New avatar uploaded:", response.url);
    return response;
  } catch (error) {
    console.error("Error updating avatar:", error);
    fs.unlinkSync(localFilePath);
    return null;
  }
};

The same logic is applied to updating cover images:

const updateCoverImage = async (oldCloudinaryUrl, localFilePath) => {
  // Similar logic to updateAvatar
};

Deleting Images

When a user deletes their profile or a post, associated images must also be deleted from Cloudinary to free up space.

const deleteImage = async (oldCloudinaryUrl) => {
  try {
    if (!oldCloudinaryUrl) {
      return null;
    }

    const publicId = oldCloudinaryUrl?.split("/").pop().split(".")[0] || null;

    if (publicId) {
      await cloudinary.uploader.destroy(`home/learnDummy/${publicId}`);
      console.info("Image deleted:", publicId);
    }

    return true;
  } catch (error) {
    console.error("Error deleting image:", error);
    return null;
  }
};

Automating Image Cleanup with Mongoose Hooks

To ensure images are deleted when a user or post is removed, we use Mongoose pre-hooks.

postSchema.pre("deleteOne", { document: true, query: false }, async function (next) {
  console.log(`Deleting comments and image for post: ${this._id}`);
  await deleteImage(this.image);
  next();
});

Whenever a post is deleted, the associated image is also deleted, preventing orphaned files from accumulating in Cloudinary.

Conclusion

By integrating Cloudinary in CampusX, we optimize image storage, improve load times, and automate media management. Cloudinary’s CDN ensures faster image delivery, while its API allows efficient handling of uploads, updates, and deletions. These optimizations contribute to an improved user experience, reduced server load, and seamless media management.

Mastering MongoDB with Mongoose: How CampusX Optimizes Data Queries

Prathviraj H — Fri, 14 Mar 2025 14:56:04 +0000

MongoDB, a NoSQL database, is a powerhouse when handling large-scale data. CampusX leverages MongoDB along with Mongoose, an ODM (Object Data Modeling) library, to structure and optimize database interactions. One of the core aspects of our implementation is MongoDB's aggregation pipelines, which allow us to efficiently fetch, transform, and compute data in a single query.

What is Mongoose?

Mongoose is a schema-based solution for MongoDB that provides a layer of abstraction, making it easier to interact with the database. It enables defining schemas, applying validation, and using middleware for handling complex operations.

Why Use Aggregation Pipelines?

MongoDB’s aggregation framework is a powerful feature that allows performing complex data transformations on the server side. Instead of fetching raw data and processing it in the application, aggregation pipelines execute these operations directly in the database, improving efficiency and performance.

Example: Fetching a Post with Mongoose Aggregation

One of the key functionalities in CampusX is retrieving posts along with associated details such as the author, comments, and follower count. Instead of making multiple queries, we optimize this using a MongoDB aggregation pipeline:

const post = await Post.aggregate([
    { $match: { _id: new mongoose.Types.ObjectId(postId) } },
    {
      $lookup: {
        from: "users",
        localField: "author",
        foreignField: "_id",
        as: "authorDetails",
      },
    },
    { $unwind: "$authorDetails" },
    {
      $lookup: {
        from: "comments",
        localField: "_id",
        foreignField: "post",
        as: "comments",
      },
    },
    {
      $lookup: {
        from: "subscriptions",
        localField: "author",
        foreignField: "channel",
        as: "followers",
      },
    },
    {
      $addFields: {
        likeCount: { $size: "$likes" },
        commentCount: { $size: "$comments" },
        followerCount: { $size: "$followers" },
      },
    },
]);

Breakdown of the Pipeline Stages:

$match: Filters the post by its unique _id.
$lookup (Users Collection): Joins the users collection to get the author details.
$unwind: Converts the array of author details into a single object.
$lookup (Comments Collection): Fetches all comments associated with the post.
$lookup (Subscriptions Collection): Retrieves followers of the author.
$addFields: Computes additional fields like likeCount, commentCount, and followerCount for quick reference.

This approach ensures we fetch all necessary data in one optimized query rather than executing multiple queries separately.

Schema Definition and Middleware in Mongoose

Our Post schema defines relationships and pre-processing steps before deletion.

const postSchema = new mongoose.Schema(
  {
    author: {
      type: mongoose.Schema.Types.ObjectId,
      ref: "User",
      required: true,
    },
    content: { type: String, required: true },
    image: { type: String },
    category: {
      type: String,
      enum: ["general", "exams", "placements", "competitions", "hackathons", "lost_found"],
      default: "general",
    },
    likes: [{ type: mongoose.Schema.Types.ObjectId, ref: "User" }],
    likesCount: { type: Number, default: 0 },
    comments: [{ type: mongoose.Schema.Types.ObjectId, ref: "Comment" }],
  },
  { timestamps: true }
);

Handling Deletions with Middleware

Mongoose allows us to trigger logic before deleting a post. The following middleware ensures associated comments and images are also removed when a post is deleted:

postSchema.pre("deleteOne", { document: true, query: false }, async function (next) {
    console.log(`Deleting comments and image for post: ${this._id}`);

    // Delete Comments
    await Comment.deleteMany({ post: this._id });

    // Delete Post Image if Exists
    await deleteImage(this.image);
    next();
});

postSchema.pre("deleteMany", { document: false, query: true }, async function (next) {
    const posts = await this.model.find(this.getFilter());

    for (const post of posts) {
        console.log(`Deleting comments and image for post: ${post._id}`);

        await Comment.deleteMany({ post: post._id });
        await deleteImage(post.image);
    }
    next();
});

This ensures no orphaned records are left in the database after a post is deleted.

Why This Matters for CampusX?

Performance Boost: The aggregation pipeline reduces multiple database calls, making queries significantly faster.
Data Integrity: Middleware ensures that when a post is deleted, related comments and images are also removed.
Schema Validation: Mongoose enforces structured data, reducing potential errors.
Better Readability & Maintainability: Using Mongoose schemas and middleware makes the codebase easier to manage.

By combining MongoDB’s raw power with Mongoose’s flexibility, CampusX ensures an efficient, scalable, and maintainable database structure. 🚀

OTP Verification in CampusX Using Brevo SMTP

Prathviraj H — Fri, 14 Mar 2025 14:33:34 +0000

Introduction

Email verification is a critical security feature in any web application. CampusX leverages Brevo SMTP (formerly Sendinblue) to send OTPs for user authentication and email verification. This ensures secure and reliable email delivery.

Why Brevo SMTP?

Reliable Delivery: Ensures OTP emails don’t land in spam.
Scalability: Handles high email traffic effortlessly.
Easy Integration: Works with Nodemailer for seamless email sending.
Cost-Effective: Affordable compared to other email services.

Setting Up Brevo SMTP in CampusX

Step 1: Configure Brevo SMTP

Sign up on Brevo and go to SMTP & API.
Generate SMTP credentials.
Add these credentials to your .env file:

   SMTP_HOST=smtp-relay.brevo.com
   SMTP_PORT=587
   SMTP_USER=your_brevo_username
   SMTP_PASS=your_brevo_password

Implementing OTP Sending in CampusX

Install Nodemailer

sh npm install nodemailer

OTP Email Service

`js
import nodemailer from 'nodemailer';
import dotenv from 'dotenv';
dotenv.config();

const transporter = nodemailer.createTransport({
host: process.env.SMTP_HOST,
port: process.env.SMTP_PORT,
auth: {
user: process.env.SMTP_USER,
pass: process.env.SMTP_PASS,
},
});

export const sendOTP = async (email, otp) => {
const mailOptions = {
from: 'no-reply@campusx.com',
to: email,
subject: 'CampusX OTP Verification',
text: Your OTP is: ${otp}. It is valid for 10 minutes.
};
await transporter.sendMail(mailOptions);
};
`

Verifying OTP

CampusX stores OTPs temporarily in Redis with an expiration time.

`js
import Redis from 'ioredis';
const redis = new Redis();

export const verifyOTP = async (email, enteredOtp) => {
const storedOtp = await redis.get(otp:${email});
if (!storedOtp || storedOtp !== enteredOtp) {
throw new Error('Invalid or expired OTP');
}
await redis.del(otp:${email}); // Remove OTP after verification
return true;
};
`

Conclusion

Using Brevo SMTP with CampusX ensures secure, scalable, and efficient OTP delivery. Integrating Redis for OTP storage prevents unnecessary database queries while enhancing security.

🔹 Looking for a reliable email verification setup? Try Brevo SMTP! 🚀

Secure Authentication in CampusX Using JWT

Prathviraj H — Fri, 14 Mar 2025 14:29:45 +0000

Introduction

Authentication is a critical part of any web application. In CampusX, we use JWT (JSON Web Tokens) to handle user authentication efficiently and securely. JWT provides a stateless way to verify users while minimizing database queries.

This blog explains:

What JWT is and why it's important.
How CampusX uses access and refresh tokens.
How token refreshing ensures seamless user experience.

What is JWT?

JWT is a compact and self-contained token format used for securely transmitting information between parties as a JSON object. It consists of three parts:

Header – Contains metadata like token type and signing algorithm.
Payload – Stores claims (user information, expiry time, etc.).
Signature – Ensures token integrity using a secret key.

Example of a JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJfaWQiOiIxMjM0IiwiaWF0IjoxNjExNjE2MDB9
.4xvNcTkORHj9xE8TftRkEw7sdJjxUX9PYG6xRJOnhZk

JWT is commonly used for authentication because it eliminates the need for session storage and repeated database queries.

Access & Refresh Tokens in CampusX

CampusX uses access tokens for authentication and refresh tokens for renewing access tokens without requiring the user to log in again.

1. Generating Tokens

const generateAccessAndRefreshTokens = async (userId) => {
  try {
    const user = await User.findById(userId);
    const accessToken = user.generateAccessToken();
    const refreshToken = user.generateRefreshToken();

    user.refreshToken = refreshToken;
    await user.save({ validateBeforeSave: false });

    return { accessToken, refreshToken };
  } catch (error) {
    throw new ApiError(
      STATUS_CODES.INTERNAL_ERROR,
      "Error generating access and refresh tokens"
    );
  }
};

Here, the user's access and refresh tokens are generated and stored securely.

JWT Authentication Middleware

The verifyJWT middleware protects routes by verifying JWT tokens before allowing access.

export const verifyJWT = AsyncHandler(async (req, res, next) => {
  try {
    const token = req.cookies?.accessToken || req.header("Authorization")?.replace("Bearer ", "");
    if (!token) {
      throw new ApiError(401, "Unauthorized request");
    }

    const decodedToken = jwt.verify(token, process.env.ACCESS_TOKEN_SECRET);
    const user = await User.findById(decodedToken._id).select("-password -refreshToken");
    if (!user) {
      throw new ApiError(402, "Invalid access token");
    }

    req.user = user;
    next();
  } catch (error) {
    throw new ApiError(401, "Token expired");
  }
});

This ensures only authenticated users can access protected resources.

Refreshing Expired Tokens

If the access token expires, CampusX uses the refresh token to generate a new access token, avoiding user logouts.

const refreshAccessToken = AsyncHandler(async (req, res) => {
  const incomingRefreshToken = req.cookies.refreshToken || req.body.refreshToken;
  if (!incomingRefreshToken) {
    throw new ApiError(STATUS_CODES.UNAUTHORIZED, "Refresh token not found");
  }

  try {
    const decodedToken = jwt.verify(incomingRefreshToken, process.env.REFRESH_TOKEN_SECRET);
    const user = await User.findById(decodedToken._id);

    if (!user || incomingRefreshToken !== user.refreshToken) {
      throw new ApiError(STATUS_CODES.UNAUTHORIZED, "Invalid refresh token");
    }

    const { accessToken, refreshToken } = await generateAccessAndRefreshTokens(user._id);
    res
      .status(STATUS_CODES.OK)
      .cookie("accessToken", accessToken, { httpOnly: true, secure: true })
      .cookie("refreshToken", refreshToken, { httpOnly: true, secure: true })
      .json(new ApiResponse(STATUS_CODES.OK, { accessToken, refreshToken }, "Access token refreshed"));
  } catch (error) {
    throw new ApiError(STATUS_CODES.INTERNAL_ERROR, "Error refreshing access token: " + error.message);
  }
});

Fetching User on Page Refresh

CampusX calls fetchUser on every page load to refresh expired access tokens.

const fetchUser = async () => {
  try {
    const res = await axiosInstance.get("/users/current-user");
    setUser(res.data?.data?.user);
  } catch (err) {
    if (err.response?.status === 401) {
      setUser(null);
    }
    if (err.response?.status === 403) {
      console.log("Access Token Expired, Refreshing...");
      try {
        await axiosInstance.post("/users/refresh-token");
        return fetchUser(); // Retry the original request
      } catch (refreshErr) {
        toast.error("Session expired, Please login again!");
      }
    }
    throw err;
  }
};

How it Works:

Calls /users/current-user to check if the user is logged in.
If the access token is expired (403 error), it tries to refresh it using /users/refresh-token.
If refreshing fails, prompts the user to log in again.

Conclusion

JWT authentication in CampusX ensures:
✅ Secure user authentication.

✅ Efficient token-based session management.

✅ Seamless token refresh without re-login.

By implementing access & refresh tokens, CampusX provides a smooth user experience while maintaining strong security. 🚀

🔹 Try implementing JWT authentication in your projects!

Boosting Performance with Redis Caching in CampusX

Prathviraj H — Fri, 14 Mar 2025 14:16:27 +0000

Introduction

Redis is a powerful in-memory data structure store used for caching, message brokering, and real-time analytics. It significantly improves performance by reducing database queries and delivering faster responses.

CampusX, my MERN stack-based social platform, leverages Redis for caching frequently accessed data like bookmarks and posts. This blog explains how Redis is integrated into CampusX for efficient data retrieval and enhanced user experience.

Why Redis for Caching?

Caching reduces redundant database queries by storing frequently accessed data in memory. This is crucial for high-traffic applications where querying the database every time would introduce latency.

Key Benefits of Redis:

Blazing Fast Reads 🚀: Being an in-memory store, Redis serves cached data almost instantly.
Reduced Load on Database: Offloads frequent queries from the primary database.
Supports Expiration ⏳: Caches can have TTL (Time-To-Live) to prevent outdated data.
Key-Value Storage 🔑: Simple yet powerful data access.
Scalability: Handles thousands of requests per second.

Setting Up Redis in CampusX

Installing Redis

First, install Redis on the server:

sudo apt update
sudo apt install redis-server

Then start Redis:

sudo systemctl start redis
sudo systemctl enable redis

Install the Redis client in the Node.js backend:

npm install ioredis

Connecting Redis in CampusX

import Redis from 'ioredis';
const redis = new Redis(); // Default localhost connection

Caching Post Data

Problem:

Fetching a post by ID every time increases database load.

Solution:

Cache post data in Redis for quick retrieval.

Implementation:


//  Get Single Post by ID with Aggregation
const getPostById = AsyncHandler(async (req, res) => {
  const postId = req.params.id;
  const cachedPost = await client.get(`post:${postId}`);

  //check for the cached post.
  if (cachedPost) {
    return res.json(
      new ApiResponse(
        STATUS_CODES.OK,
        JSON.parse(cachedPost),
        "Post from Redis cache"
      )
    );
  }
  //Database Call
  const post = await Post.aggregate([
    { $match: { _id: new mongoose.Types.ObjectId(postId) } },
    {
      $lookup: {
        from: "users",
        localField: "author",
        foreignField: "_id",
        as: "authorDetails",
      },
    },
    { $unwind: "$authorDetails" },
    {
      $lookup: {
        from: "comments",
        localField: "_id",
        foreignField: "post",
        as: "comments",
      },
    },
    {
      $lookup: {
        from: "subscriptions",
        localField: "author",
        foreignField: "channel",
        as: "followers",
      },
    },
    {
      $addFields: {
        likeCount: { $size: "$likes" },
        commentCount: { $size: "$comments" },
        followerCount: { $size: "$followers" },
      },
    },
  ]);

  if (!post.length)
    throw new ApiError(STATUS_CODES.NOT_FOUND, "Post not found");

  //cache the post to redis
  try {
    await client.setEx(`post:${postId}`, 3600, JSON.stringify(post[0]));
  } catch (err) {
    console.error("Redis caching error:", err);
  }

  res
    .status(STATUS_CODES.OK)
    .json(
      new ApiResponse(STATUS_CODES.OK, post[0], "Post fetched successfully")
    );
});
};

How It Works:

Check Redis: If post exists in cache, return it instantly.
Query MongoDB: If not found in Redis, fetch from the database.
Cache the Post: Save in Redis for subsequent requests.
Set Expiry: Automatically remove old data after 10 minutes.

Caching User Bookmarks

Problem:

Fetching user bookmarks on every request leads to unnecessary DB hits.

Solution:

Cache user bookmarks in Redis and update only when changes occur.

Implementation:


//  Get User's Bookmarked Posts
const getUserBookmarks = AsyncHandler(async (req, res) => {
  const userId = req.user._id;
  const user = await User.findById(userId);

  //chech if the bookmarks are cached
  const cachedBookmarks = await client.get(`bookmarks:${userId}`);
  console.log("cachedBookmarks", cachedBookmarks);
  if (cachedBookmarks) {
    return res.json(
      new ApiResponse(
        STATUS_CODES.OK,
        JSON.parse(cachedBookmarks),
        "bookmarks from Redis cache"
      )
    );
  }
   //Database Call
  const bookmarks = await Bookmark.find({ _id: { $in: user.bookmarks } })
    .populate("post", "content image category likesCount")
    .populate("post_owner", "fullName userName avatar");

  console.log("bookmarks", bookmarks);

  //cache the user bookmarks
  try {
    await client.setEx(`bookmarks:${userId}`, 3600, JSON.stringify(bookmarks));
    console.log("bookmarks cached");
  } catch (err) {
    console.error("Redis caching error:", err);
  }

  res
    .status(STATUS_CODES.OK)
    .json(
      new ApiResponse(STATUS_CODES.OK, bookmarks, "Bookmarked posts fetched")
    );
});

Ensuring Cache Consistency in CampusX with Redis

🔹 The Problem: Stale Cache

When users update their bookmarks, the cached data can become outdated. Instead of serving old data, CampusX ensures cache consistency by deleting the cache entry whenever a change occurs.

🛠️ How It Works

1️⃣ Check Cache: Before querying the database, Redis is checked for cached data.

2️⃣ Serve Cached Data: If available, the cached data is returned instantly.

3️⃣ Delete Cache on Update: When a bookmark is added or removed, the cache entry is deleted.

4️⃣ Fetch Fresh Data: The next request pulls updated data from the database and caches it again.

💡 Implementation

🗑️ Deleting Cache on Update

//remove the boomarks from the cache
  await client.del(`bookmarks:${req.user._id}`);
  console.log("🗑️ Cache cleared for user's bookmarks");

🚀 Why Delete Instead of Updating?

✔ Ensures fresh data – Users always get the latest updates.

✔ Simplifies cache management – No need to track and modify cache manually.

✔ Prevents stale data issues – Avoids serving outdated information.

By using this delete-and-reload approach, CampusX keeps Redis cache up-to-date efficiently! 🚀🔥

Redis Performance Tips

Set Expiry Times ⏲️: Prevents stale cache from growing indefinitely.
Use Proper Key Naming 🏷️: Consistent prefixes (post:ID, bookmarks:USER_ID) avoid conflicts.
Cache Only Essential Data 🎯: Don’t over-cache; focus on frequently accessed data.
Use Redis Pub/Sub for Real-time Updates 🔄: Sync cache with DB changes.

Conclusion

Integrating Redis in CampusX significantly improved performance by caching frequently accessed data like posts and bookmarks. This reduced database load and provided a seamless experience for users.

Caching is essential for optimizing applications, and Redis makes it incredibly easy and efficient. Whether you're handling high traffic, real-time updates, or just want faster data access, Redis is a game-changer.

🔹 Try implementing Redis caching in your projects and experience the performance boost! 🚀

Real-time Like Notifications with Redis Pub/Sub in CampusX

Prathviraj H — Fri, 14 Mar 2025 12:52:14 +0000

Introduction

Handling real-time events efficiently is crucial in any social media-like application. In CampusX, I implemented Redis Pub/Sub to manage like notifications seamlessly. This approach ensures that when a user likes a post, the owner of the post receives an instant notification via WebSockets.

This blog will break down how Redis Pub/Sub works and how it powers the real-time like notifications in CampusX.

What is Redis Pub/Sub?

Redis Pub/Sub (Publish/Subscribe) is a messaging system where publishers send messages to specific channels, and subscribers listening to those channels receive the messages instantly. Unlike traditional message queues, Redis Pub/Sub does not store messages. Once a message is delivered to all subscribers, it disappears from memory.

Key Components:

Publisher: Sends messages to a Redis channel.
Subscriber: Listens for messages on a channel.
Channel: A topic where messages are broadcasted.

Setting Up Redis Pub/Sub for Like Notifications in CampusX

1️⃣ Configuring Redis Client

First, I created a Redis configuration file (redis.js) to manage the publisher and subscriber connections:

import { createClient } from "redis";

const pub = createClient();
const sub = createClient();

pub.on("error", (err) => console.error("❌ Redis Publisher Error:", err));
sub.on("error", (err) => console.error("❌ Redis Subscriber Error:", err));

async function connectRedis() {
  try {
    await pub.connect();
    console.log("✅ Redis Publisher Connected");
    await sub.connect();
    console.log("✅ Redis Subscriber Connected");
  } catch (err) {
    console.error("❌ Redis Connection Error:", err);
  }
}

connectRedis();

export { pub, sub };

This ensures that both the publisher and subscriber are connected when the backend starts.

2️⃣ Publishing Like Events

Whenever a user likes a post, the backend publishes a message on the like_status channel:

import { pub } from "../config/redis.js";

async function publishLikeStatus(status, postOwnerId, userId) {
  console.log("Published Like Status");

  if (!pub.isReady) {
    console.log("🟡 Connecting Redis Publisher...");
    await pub.connect();
  }

  try {
    await pub.publish(
      "like_status",
      JSON.stringify({ status, postOwnerId, userId })
    );
    console.log("✅ Like status published successfully");
  } catch (err) {
    console.error("❌ Error publishing like status:", err);
  }
}

export default publishLikeStatus;

This function takes in the like status, the owner of the post, and the user who liked the post. It then publishes this information on Redis for subscribers to pick up.

3️⃣ Subscribing to Like Events

The backend subscribes to the like_status channel to listen for new like events and sends notifications via WebSockets:

import { sub } from "../config/redis.js";

const subscribeLikeStatus = async (io, userSockets) => {
  sub.on("error", (err) => console.error("❌ Redis Subscriber Error:", err));

  if (!sub.isReady) {
    console.log("🟡 Connecting Redis subscriber...");
    await sub.connect();
  }

  try {
    await sub.subscribe("like_status", (message) => {
      console.log("📩 Message received:", message);
      const data = JSON.parse(message);
      console.log("📌 Data received:", data);

      // Check if the post owner is online
      const ownerSocketId = userSockets.get(data.postOwnerId);
      console.log("📡 Owner Socket ID:", ownerSocketId);

      if (ownerSocketId) {
        io.to(ownerSocketId).emit("like_status", data);
        console.log("📤 Sent like notification to:", ownerSocketId);
      } else {
        console.log("⚠️ Post owner not online:", data.postOwnerId);
      }
    });

    console.log("✅ Subscribed to 'like_status' channel.");
  } catch (err) {
    console.error("❌ Redis subscription error:", err);
  }
};

export { subscribeLikeStatus };

This function listens for new messages and checks if the post owner is online. If they are, it sends a WebSocket event notifying them of the new like.

4️⃣ WebSocket Integration

I integrated WebSockets to track connected users and send real-time notifications:

const userSockets = new Map();

const connectWebSocket = (server) => {
  const io = new Server(server, {
    cors: { origin: "*" },
  });

  io.on("connection", (socket) => {
    console.log("Client connected:", socket.id);

    socket.on("register", (userId) => {
      console.log("🔹 User registered(ID):", userId, "Socket ID:", socket.id);
      userSockets.set(userId, socket.id);
      socket.userId = userId;
    });

    socket.on("disconnect", () => {
      if (socket.userId) {
        userSockets.delete(socket.userId);
        console.log("🔻 User disconnected:", socket.userId);
      }
      console.log("Client disconnected:", socket.id);
    });
  });

  return io;
};

export { connectWebSocket, userSockets };

This keeps track of online users and cleans up the memory when users disconnect.

How It Works End-to-End

1️⃣ A user likes a post, triggering publishLikeStatus.

2️⃣ Redis receives the message and delivers it to all subscribers.

3️⃣ subscribeLikeStatus processes the message and checks if the post owner is online.

4️⃣ If online, the notification is sent via WebSockets.

5️⃣ The frontend receives the WebSocket event and displays a toast notification.

Why Use Redis Pub/Sub?

✅ Fast & Lightweight – Delivers messages instantly without storing them.

✅ Decoupled Architecture – Publishers and subscribers don’t need direct knowledge of each other.

✅ Scalability – Supports multiple subscribers across different backend services.

Conclusion

By integrating Redis Pub/Sub, CampusX efficiently handles real-time like notifications without overloading the database. This architecture ensures that users receive instant updates while keeping the system scalable and responsive.

If you're building a real-time application, consider Redis Pub/Sub for event-driven communication. 🚀

Understanding SSL/TLS Encryption: How Session Keys Secure Your Communication

Prathviraj H — Mon, 10 Mar 2025 17:20:03 +0000

When developing a web application, ensuring secure communication between the client and server is critical. This is where SSL/TLS encryption comes in, protecting sensitive data from eavesdropping, tampering, and forgery.

But how does it actually work? What happens behind the scenes when a client connects to a secure server? In this blog, we'll break down the SSL/TLS handshake, the role of public/private keys, and the importance of session keys in both production and local development environments.

1. How SSL/TLS Works: The Handshake Process

When a client (browser, mobile app, etc.) connects to a server over HTTPS, an SSL/TLS handshake happens before any data is exchanged. Here's the step-by-step breakdown:

Step 1: Client Hello

The client sends a request to the server, indicating it wants a secure connection.
It includes a list of supported TLS versions and encryption algorithms.

Step 2: Server Hello & Certificate Exchange

The server responds with a digital certificate (cert.pem) that proves its authenticity.
This certificate contains the server’s public key and is signed by a trusted Certificate Authority (CA).
The client verifies this certificate to confirm it's talking to the right server.

Step 3: Session Key Generation

The client generates a random session key.
It encrypts this session key using the server’s public key (from the certificate) and sends it to the server.
The server decrypts it using its private key (key.pem).

Step 4: Secure Communication Begins

Both the client and server now use the same session key for encrypting and decrypting messages.
This session key is used with symmetric encryption algorithms like AES (Advanced Encryption Standard) to ensure fast and secure data exchange.

Why Use a Session Key Instead of Public/Private Keys for Every Request?
✔ Performance – Asymmetric encryption (public/private key) is slow, but symmetric encryption (session key) is much faster.
✔ Efficiency – The session key allows secure communication without needing to re-encrypt every request with the server’s public key.
✔ Security – Even if the session key is compromised, it only affects one session (not all future communications).

2. Setting Up HTTPS in Local Development

In local development, you don’t get a certificate from a Certificate Authority (CA). Instead, you can generate a self-signed certificate using OpenSSL.

Run the following command in your terminal:

openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes

This creates:

key.pem – The private key (never share this)
cert.pem – The self-signed certificate (used to prove authenticity)

Configuring HTTPS in Express (Node.js)

import https from 'https';
import fs from 'fs';
import express from 'express';

const app = express();
const options = {
  key: fs.readFileSync("key.pem"),
  cert: fs.readFileSync("cert.pem")
};

https.createServer(options, app).listen(443, () => {
  console.log("Server running on https://localhost:443");
});

💡 Important: Add key.pem and cert.pem to .gitignore so they don’t get pushed to GitHub.

echo "key.pem" >> .gitignore
echo "cert.pem" >> .gitignore

3. Implementing HTTPS in Production

In production, you’ll use a trusted CA like:

Let’s Encrypt (free SSL certificates)
Cloudflare SSL (free/proxy-based SSL)
Paid certificates from companies like DigiCert, GoDaddy, etc.

Using Nginx for HTTPS (Production Setup)

If you’re using Nginx as a reverse proxy, configure it like this:

server {
    listen 443 ssl;
    server_name example.com;

    ssl_certificate /etc/ssl/certs/fullchain.pem;
    ssl_certificate_key /etc/ssl/private/privkey.pem;

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Run the following command to obtain an SSL certificate with Let’s Encrypt:

sudo certbot --nginx -d example.com

This automatically configures SSL for Nginx.

4. How Clients Verify HTTPS

Once the SSL handshake is complete:
✔ The browser checks the certificate (ensuring it's valid and issued by a trusted CA).
✔ The session key is established (allowing encrypted communication).
✔ All requests and responses are encrypted (protecting user data).

You can check SSL details in the browser:

Click the lock icon in the address bar.
View certificate information.

5. Conclusion

By understanding SSL/TLS encryption, you ensure that your web application is secure both in development and production.

🔐 In local development, use self-signed certificates.
🔐 In production, get a trusted CA certificate and configure Nginx/Apache.
🔑 Session keys are used for efficient, secure communication.

Implementing HTTPS properly builds trust with users, prevents security breaches, and ensures compliance with security best practices. 🚀

Why Redis is a Game-Changer for High-Performance Applications

Prathviraj H — Sun, 09 Mar 2025 18:56:27 +0000

Introduction

Ever wondered why some applications feel blazing fast while others lag? One of the secrets behind high-performance apps is Redis—a powerful in-memory database that speeds up data access like no other.

In this blog, we’ll break down what Redis is, how it works, and why it’s widely used in modern applications.

What is Redis?

Redis (Remote Dictionary Server) is an open-source, in-memory key-value store known for its speed, simplicity, and versatility. Unlike traditional databases that store data on disk, Redis keeps everything in RAM, making read and write operations extremely fast.

Redis is often used as:

✅ A cache – To store frequently accessed data and reduce
database queries.
✅ A message broker – For real-time communication between
services.
✅ A session store – To manage user sessions efficiently.
✅ A leaderboard store – For gaming applications with real-time
ranking.

Why Use Redis?

Traditional databases (like MySQL, PostgreSQL) write and retrieve data from disk, causing delays. Redis, on the other hand, keeps data in memory, making it 100x faster for read/write operations.

Here’s why Redis is a game-changer:

1️⃣ Super Fast – Handles millions of requests per second.

2️⃣ Low Latency – No disk reads/writes; everything happens in RAM.

3️⃣ Flexible Data Structures – Supports strings, hashes, lists, sets, sorted sets, bitmaps, and hyperloglogs.

4️⃣ Persistence Options – Can save data periodically to disk (snapshotting) or log each write (AOF – Append Only File).

5️⃣ Scalability – Works in a distributed setup with clustering and replication

How Redis Works

Redis follows a simple key-value store model, but it’s not limited to just key-value pairs. It supports advanced data structures:

Example of setting and getting a value in Redis:

SET username "prathvi"
GET username  # Returns "prathvi"

Redis in Action: Real-World Use Cases

1️⃣ Caching for Speed Boost
Instead of hitting the database every time, store frequently accessed data in Redis.

SET user:123 "John Doe"
EXPIRE user:123 3600  # Auto-delete after 1 hour

➡️ Reduces database load and improves response times.

2️⃣ Real-Time Chat with Pub/Sub
Redis publish/subscribe (Pub/Sub) allows real-time messaging between services.

PUBLISH chat "Hello, World!"
SUBSCRIBE chat  # Listens for messages in the 'chat' channel

➡️ Used in chat apps, live notifications, and event streaming.

3️⃣ Background Jobs with Redis Queues
For delayed processing, Redis acts as a queue where tasks are pushed and processed asynchronously.

LPUSH job_queue "process_user_data"
RPOP job_queue  # Retrieves the task for processing

➡️ Used in email processing, report generation, and task scheduling.

Conclusion

Redis is a must-have for modern applications that require speed, scalability, and real-time performance. Whether you need a fast cache, message broker, or job queue, Redis delivers unmatched efficiency.

🚀 If your app needs to handle high traffic with low latency, Redis is your best friend!

Have You Ever Thought About What Cloudflare Does?

Prathviraj H — Sun, 09 Mar 2025 18:42:41 +0000

Introduction

If you've ever browsed the internet, chances are you've interacted with Cloudflare without even knowing it. But what exactly does Cloudflare do? Is it just a security service? A CDN? A performance booster? The answer: all of the above and more!

In this blog, we’ll break down how Cloudflare works and why it’s a crucial tool for modern websites.

What is Cloudflare?

Cloudflare is a network security, performance, and reliability company that provides services like DDoS protection, content delivery, DNS management, caching, and more. It acts as a reverse proxy between your website and users, helping improve speed, security, and uptime.

Why Do We Need Cloudflare?

Websites today face several challenges:

DDoS Attacks – Websites can be flooded with fake traffic, causing downtime.

Slow Load Times – Without a CDN, loading static files (CSS, JS, images) can be slow for global users.

Unoptimized Traffic Routing – A direct connection to the origin server may not be the fastest route.

Security Risks – Attackers can exploit vulnerabilities if the server is exposed.

DNS Latency – Traditional DNS servers may slow down website resolution.

Cloudflare solves these problems by providing faster, safer, and more reliable website access.

How Cloudflare Works

Cloudflare sits between the user and the website’s origin server, handling requests before they reach the backend.

1️⃣ Reverse Proxy & DDoS Protection
Cloudflare acts as a middleman for all incoming traffic, filtering out malicious requests before they hit the origin server. It detects and mitigates DDoS attacks in real time.

2️⃣ Content Delivery Network (CDN)
Cloudflare has data centers in 300+ cities worldwide. When a user visits a website, Cloudflare serves cached content from the nearest location, reducing load times and bandwidth usage.

3️⃣ Load Balancing
If your site runs on multiple servers, Cloudflare distributes traffic intelligently to ensure high availability.

4️⃣ DNS Management
Cloudflare provides a fast and secure DNS service, resolving domain names faster than traditional DNS providers.

5️⃣ SSL/TLS Encryption
Cloudflare provides free SSL certificates, ensuring secure HTTPS connections without manual configuration.

Who Uses Cloudflare?

🚀 Companies like Netflix, Uber, Medium, Shopify, and Discord use Cloudflare for security, speed, and reliability.

Conclusion

Cloudflare is more than just a CDN or security tool—it’s a full-stack performance, security, and reliability solution for modern web applications.

🌍 Whether you're running a personal blog or a high-traffic enterprise website, Cloudflare helps keep your site fast, secure, and online.

🔥 Still not using Cloudflare? Maybe it’s time to start!

Forem: Prathviraj H

Using Multiple GitHub Accounts

Understanding REST APIs and Best Practices (With CampusX Implementation)

What is a REST API?

Key Features of REST APIs:

Best Practices for Designing REST APIs

1. Use Meaningful Resource Names

2. Follow HTTP Methods Correctly

3. Use Status Codes Properly

4. Paginate Large Results

5. Secure APIs with Authentication

6. Implement Versioning

7. Use Consistent Error Handling

How REST APIs Are Used in CampusX

1. User Authentication (JWT)

2. Post Management

3. Comments & Engagements

4. User Profile & Account Management

5. Bookmark & Follow System

Conclusion

Efficient File Uploads in CampusX with Multer

Why Multer?

How Multer Works in CampusX

Usage in CampusX

**Optimizing Image Management in CampusX with Cloudinary**

Why Cloudinary?

Key Benefits of Using Cloudinary in CampusX

Cloudinary Setup in CampusX

Uploading Images to Cloudinary

Updating User Avatars & Cover Images

Deleting Images

Automating Image Cleanup with Mongoose Hooks

Conclusion

**Mastering MongoDB with Mongoose: How CampusX Optimizes Data Queries**

What is Mongoose?

Why Use Aggregation Pipelines?

Example: Fetching a Post with Mongoose Aggregation

Breakdown of the Pipeline Stages:

Schema Definition and Middleware in Mongoose

Handling Deletions with Middleware

Why This Matters for CampusX?

OTP Verification in CampusX Using Brevo SMTP

Introduction

Why Brevo SMTP?

Setting Up Brevo SMTP in CampusX

Step 1: Configure Brevo SMTP

Implementing OTP Sending in CampusX

Install Nodemailer

OTP Email Service

Verifying OTP

Conclusion

Secure Authentication in CampusX Using JWT

Introduction

What is JWT?

Access & Refresh Tokens in CampusX

1. Generating Tokens

JWT Authentication Middleware

Refreshing Expired Tokens

Fetching User on Page Refresh

How it Works:

Conclusion

Boosting Performance with Redis Caching in CampusX

Introduction

Why Redis for Caching?

Key Benefits of Redis:

Setting Up Redis in CampusX

Installing Redis

Connecting Redis in CampusX

Caching Post Data

Problem:

Solution:

Implementation:

How It Works:

Caching User Bookmarks

Problem:

Solution:

Implementation:

Ensuring Cache Consistency in CampusX with Redis

🔹 The Problem: Stale Cache

🛠️ How It Works

Optimizing Image Management in CampusX with Cloudinary

Mastering MongoDB with Mongoose: How CampusX Optimizes Data Queries