new

.gitignore

@@ -1,24 +1,5 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-lerna-debug.log*
+# Environment variables
+.env
 
-node_modules
-dist
-dist-ssr
-*.local
 
-# Editor directories and files
-.vscode/*
-!.vscode/extensions.json
-.idea
-.DS_Store
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?
+node_modules

backend/.gitignore

@@ -0,0 +1,2 @@
+.env
+node_modules

backend/controllers/comment.controller.js

@@ -0,0 +1,63 @@
+
+import Comment from "../models/comment.model.js";
+import User from "../models/user.model.js";
+
+export const getPostComments = async (req, res) => {
+  const comments = await Comment.find({ postId: req.params.postId })
+    .populate("user", "username img")
+    .sort({ createdAt: -1 });
+
+  res.json(comments);
+};
+
+export const addComment = async (req, res) => {
+  const clerkUserId = req.auth().userId;
+  const postId = req.params.postId;
+
+  if (!clerkUserId) {
+    return res.status(401).json("Not authenticated!");
+  }
+
+  const user = await User.findOne({ clerkUserId });
+
+  const newComment = new Comment({
+    ...req.body,
+    user: user._id, // The user who made the comment
+    postId: postId, // The post the comment belongs to
+  });
+
+  const savedComment = await newComment.save();
+  setTimeout(() => {}, 1000);
+  // Populate the user field before sending the response
+  const populatedComment = await Comment.findById(savedComment._id).populate("user", "username img");
+  res.status(201).json(populatedComment);
+};
+
+export const deleteComment = async (req, res) => {
+  const clerkUserId = req.auth().userId;
+  const id = req.params.id;
+
+  if (!clerkUserId) {
+    return res.status(401).json("Not authenticated!");
+  }
+
+  const role = req.auth().sessionClaims?.metadata?.role || "user";
+
+  if (role === "admin") {
+    await Comment.findByIdAndDelete(req.params.id);
+    return res.status(200).json("Comment has been deleted");
+  }
+
+  const user = await User.findOne({ clerkUserId });
+
+  const deletedComment = await Comment.findOneAndDelete({
+    _id: id,
+    user: user._id,
+  });
+
+  if (!deletedComment) {
+    return res.status(403).json("You can delete only your comment!");
+  }
+
+  res.status(200).json("Comment deleted");
+};

backend/controllers/post.controller.js

@@ -0,0 +1,111 @@
+import ImageKit from "imagekit";
+import  User  from "../models/user.model.js";
+import Post from "../models/post.model.js"
+
+import dotenv from "dotenv";
+dotenv.config();
+
+export const getPosts = async (req, res) =>  {
+const page = parseInt(req.query.page) || 1;
+const limit = parseInt(req.query.limit) || 5;
+const skip = (page - 1) * limit;
+//const sort = { createdAt: -1 };
+
+    const posts = await Post
+    .find()
+    .populate("user","username")
+    .limit(limit)
+    .skip(skip);
+    const totalPosts = await Post.countDocuments();
+    const hasMore = page * limit < totalPosts;
+
+
+    res.status(200).json({ posts, hasMore });
+
+};
+export const getPost = async (req, res) => {
+    const post = await Post.findOne({slug:req.params.slug})
+    .populate("user","username img");
+    res.status(200).json(post);
+
+};
+export const createPost = async (req, res) => {
+  try {
+    const { title, desc, category, content, img } = req.body;
+    const clerkUserId = req.auth().userId;
+    if (!clerkUserId) {
+      return res.status(401).json({ message: "Unauthorized" });
+    }
+    if (!title || !category || !content) {
+      return res.status(400).json({ message: "Title, category, and content are required." });
+    }
+    const user = await User.findOne({ clerkUserId });
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    let slug = title.replace(/ /g, "-").toLowerCase();
+    let existingPost = await Post.findOne({ slug });
+    let counter = 2;
+    while (existingPost) {
+      slug = `${slug}-${counter}`;
+      existingPost = await Post.findOne({ slug });
+      counter++;
+    }
+    const newPost = new Post({
+      user: user._id,
+      slug,
+      title,
+      desc,
+      category,
+      content,
+      img,
+    });
+    const post = await newPost.save();
+    res.status(201).json(post);
+  } catch (error) {
+    console.error("Error creating post:", error);
+    // Handle Mongoose validation errors
+    if (error.name === 'ValidationError') {
+      const errors = Object.values(error.errors).map(err => err.message);
+      return res.status(400).json({ 
+        message: "Validation failed", 
+        errors: errors 
+      });
+    }
+
+    res.status(500).json({ message: "Failed to create post", error: error.message });
+  }
+};
+export const deletePost = async (req, res) => {
+    const clerkUserId = req.auth().userId;
+    if(!clerkUserId){
+        return res.status(401).json({message: "Unauthorized"});
+    }
+    const user = await User.findOne({clerkUserId});
+    const post = await Post.findOneAndDelete({_id: req.params.id,user: user._id,});
+    res.status(200).json("post has been deleted");
+};
+
+
+//console.log("ImageKit ENV:", {
+//  publicKey: process.env.IMAGEKIT_PUBLIC_KEY,
+//  privateKey: process.env.IMAGEKIT_PRIVATE_KEY ? "loaded" : "missing",
+//  urlEndpoint: process.env.IMAGEKIT_URL_ENDPOINT,
+//});
+//
+ const imagekit = new ImageKit({
+
+   publicKey: process.env.IMAGEKIT_PUBLIC_KEY,
+   privateKey:  process.env.IMAGEKIT_PRIVATE_KEY,
+   urlEndpoint: process.env.IMAGEKIT_URL_ENDPOINT,
+ });
+
+export const uploadAuth = async(req, res) => {
+  try {
+    const result = imagekit.getAuthenticationParameters();
+    res.status(200).json(result);
+  } catch (error) {
+    console.error("ImageKit Auth Generation Error:", error);
+    res.status(500).json({ message: "Failed to generate authentication parameters." });
+  }
+};

backend/controllers/user.controller.js

@@ -0,0 +1,46 @@
+import User from "../models/user.model.js";
+
+export const getUserSavedPosts = async (req, res) => {
+  const clerkUserId = req.auth().userId;
+
+  if (!clerkUserId) {
+    return res.status(401).json("Not authenticated!");
+  }
+
+  const user = await User.findOne({ clerkUserId });
+
+  if (!user) {
+    return res.status(404).json("User not found!");
+  }
+
+  res.status(200).json(user.savedPosts);
+};
+
+export const savePost = async (req, res) => {
+  const clerkUserId = req.auth().userId;
+  const postId = req.body.postId;
+
+  if (!clerkUserId) {
+    return res.status(401).json("Not authenticated!");
+  }
+
+  const user = await User.findOne({ clerkUserId });
+
+  if (!user) {
+    return res.status(404).json("User not found!");
+  }
+
+  const isSaved = user.savedPosts.some((p) => p === postId);
+
+  if (!isSaved) {
+    await User.findByIdAndUpdate(user._id, {
+      $push: { savedPosts: postId },
+    });
+  } else {
+    await User.findByIdAndUpdate(user._id, {
+      $pull: { savedPosts: postId },
+    });
+  }
+
+  res.status(200).json(isSaved ? "Post unsaved" : "Post saved");
+};

backend/controllers/webhook.controller.js

@@ -0,0 +1,40 @@
+import User from "../models/user.model.js";
+import { Webhook } from "svix";
+
+
+export const clerkWebHook = async (req, res) => {
+    const WEBHOOK_SECRET = process.env.CLERK_WEBHOOK_SECRET;
+    if(!WEBHOOK_SECRET){
+        throw new Error("CLERK_WEBHOOK_SECRET is not defined") 
+    }
+     const payload = req.body;
+    const headers = req.headers;
+
+    const wh = new Webhook(WEBHOOK_SECRET);
+    let evt;
+    try {
+        evt = wh.verify(payload, headers);
+    } catch (err) {
+        console.error("Webhook verification failed:", err.message);
+        return res.status(400).json({message: "Webhook verification failed"});
+    }
+
+    if (evt.type === "user.created") {
+        try {
+            const newUser = new User({
+                clerkUserId: evt.data.id,
+                username: evt.data.username || evt.data.email_addresses[0].email_address,
+                email: evt.data.email_addresses[0].email_address,
+                img: evt.data.image_url, 
+            });
+
+            await newUser.save();
+            return res.status(201).json({message: "User created successfully."});
+        } catch (err) {
+            console.error("Error creating user:", err);
+            return res.status(500).json({ message: "Internal server error while creating user." });
+        }
+    }
+    // Acknowledge other webhook events with a success response
+    return res.status(200).json({ message: "Webhook received, but no action taken." });
+}

backend/index.js

@@ -0,0 +1,53 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+import express from "express";
+import cors from "cors";
+import { clerkMiddleware } from "@clerk/express";
+
+import connectDB from "./lib/connectDB.js";
+import userRouter from "./routes/user.route.js";
+import postRouter from "./routes/post.route.js";
+import commentsRouter from "./routes/comment.route.js";
+import webhookRouter from "./routes/webhook.route.js";
+
+const app = express();
+
+// ✅ Configure CORS properly
+const allowedOrigins = ["http://localhost:5173"]; // change if needed
+const corsOptions = {
+  origin: (origin, callback) => {
+    if (!origin || allowedOrigins.includes(origin)) {
+      callback(null, true);
+    } else {
+      callback(new Error("Not allowed by CORS"));
+    }
+  },
+  optionsSuccessStatus: 200,
+};
+app.use(cors(corsOptions));
+
+app.use(clerkMiddleware());
+app.use(express.json());
+
+// ✅ Routes
+app.use("/webhooks", webhookRouter);
+app.use("/api/users", userRouter);
+app.use("/api/posts", postRouter);
+app.use("/api/comments", commentsRouter);
+
+// ✅ Error handler
+//app.use((err, req, res, next) => {
+//  res.status(err.status || 500).json({
+//    message: err.message || "Something went wrong",
+//    status: err.status,
+//    stack: process.env.NODE_ENV === "development" ? err.stack : undefined,
+//  });
+//});
+
+const port = process.env.PORT || 3000;
+app.listen(port, () => {
+  connectDB();
+
+  console.log(`✅ Server is running on port ${port}`);
+});

backend/lib/connectDB.js

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+
+const connectDB = async () => {
+    try{
+      await mongoose.connect(process.env.MONGO);
+        console.log("DB is successfully connected");
+    }
+    catch(err)
+    {
+        console.log(err)
+    }
+}
+export default connectDB;

backend/models/comment.model.js

@@ -0,0 +1,31 @@
+import { Schema } from "mongoose";
+import mongoose from "mongoose";
+
+
+
+const commentSchema = new Schema({
+      user: {
+        type: Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+
+    },
+    postId: {
+        type: Schema.Types.ObjectId,
+        ref: "Post",
+        required: true,
+
+    },
+    desc: {
+        type: String,
+        required: true,
+
+    },
+
+
+},
+    {
+        timestamps: true
+    });
+    export default mongoose.model("Comment", commentSchema);
+