Upload 94 files

controllers/ai/index.ts

@@ -0,0 +1,219 @@
+import { Request, Response } from "express";
+import prisma from "../../prisma/client";
+import { getGeminiResponse } from "../../utils/gemini";
+
+export const chatWithAI = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { message, projectId } = req.body;
+
+  try {
+    let projectContext = "";
+    let difficultyMode: string | null = null;
+
+    // 1. Fetch project context if projectId is provided
+    if (projectId) {
+      const project = await prisma.project.findUnique({
+        where: { id: projectId },
+        include: {
+          milestones: true,
+          userProjects: { where: { userId } },
+        },
+      });
+
+      if (project) {
+        difficultyMode =
+          project.userProjects?.[0]?.difficultyModeChosen || "STANDARD";
+        projectContext = `
+You are helping a student with the following project:
+Project Title: ${project.title}
+Description: ${project.description}
+Difficulty Level: ${project.difficultyLevel}
+Technologies: ${project.technologies.join(", ")}
+Estimated Time: ${project.estimatedTime}
+Chosen Difficulty Mode: ${difficultyMode}
+
+Milestones:
+${project.milestones
+  .sort((a, b) => a.milestoneNumber - b.milestoneNumber)
+  .map((m) => `${m.milestoneNumber}. ${m.title}: ${m.description}`)
+  .join("\n")}
+
+Learning Objectives:
+${project.learningObjectives.map((obj, i) => `${i + 1}. ${obj}`).join("\n")}
+`;
+      }
+    }
+
+    // 2. Define mode-specific instructions
+    let modeInstruction = "";
+    if (difficultyMode === "GUIDED") {
+      modeInstruction =
+        "The user is in GUIDED mode. Be very helpful, provide detailed explanations, and don't hesitate to give small code snippets if they are stuck.";
+    } else if (difficultyMode === "HARDCORE") {
+      modeInstruction =
+        "The user is in HARDCORE mode. Be very brief, provide only high-level conceptual hints, and never provide code solutions.";
+    } else {
+      modeInstruction =
+        "The user is in STANDARD mode. Provide balanced guidance, focus on concepts, and only provide code as a last resort.";
+    }
+
+    // 3. Build System Prompt
+    const systemPrompt = `You are an AI Guide for a project-based learning platform. 
+Your goal is to help students learn by providing guidance, not just giving away answers.
+${projectContext}
+${modeInstruction}
+Keep your responses concise and educational. Always respond in markdown format.`;
+
+    // 4. Fetch chat history
+    const history = await prisma.chatMessage.findMany({
+      where: { userId, projectId: projectId || null },
+      orderBy: { createdAt: "asc" },
+      take: 20,
+    });
+
+    const geminiHistory = history.map((msg) => ({
+      role: msg.role === "user" ? "user" : "model",
+      parts: [{ text: msg.content }],
+    }));
+
+    // 5. Get AI Response
+    const aiResponse = await getGeminiResponse(
+      `${systemPrompt}\n\nUser Question: ${message}`,
+      geminiHistory
+    );
+
+    // 6. Persist Conversation
+    await prisma.chatMessage.createMany({
+      data: [
+        {
+          userId,
+          projectId: projectId || null,
+          role: "user",
+          content: message,
+        },
+        {
+          userId,
+          projectId: projectId || null,
+          role: "assistant",
+          content: aiResponse,
+        },
+      ],
+    });
+
+    // 7. Stream response (simulated streaming)
+    res.setHeader("Content-Type", "text/plain");
+    res.setHeader("Transfer-Encoding", "chunked");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+
+    const words = aiResponse.split(" ");
+    for (let i = 0; i < words.length; i++) {
+      res.write(words[i] + " ");
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+
+    res.end();
+  } catch (error: any) {
+    console.error("Chat error:", error);
+    if (!res.headersSent) {
+      res.status(500).json({ success: false, message: error.message });
+    } else {
+      res.end();
+    }
+  }
+};
+
+export const getAllChatMessages = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+
+  try {
+    const messages = await prisma.chatMessage.findMany({
+      where: { userId },
+      orderBy: { createdAt: "asc" },
+    });
+
+    res.json({ success: true, data: messages });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const requestHint = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { projectId, milestoneNumber, difficultyMode } = req.body;
+
+  try {
+    const milestone = await prisma.projectMilestone.findUnique({
+      where: { projectId_milestoneNumber: { projectId, milestoneNumber } },
+      include: { project: true },
+    });
+
+    if (!milestone)
+      return res
+        .status(404)
+        .json({ success: false, message: "Milestone not found" });
+
+    let modeInstruction = "";
+    if (difficultyMode === "GUIDED") {
+      modeInstruction =
+        "The user is in GUIDED mode. Be very helpful and detailed.";
+    } else {
+      modeInstruction =
+        "The user is in STANDARD mode. Provide a balanced, conceptual hint.";
+    }
+
+    const modeHintsForPrompt = Array.isArray(milestone.hints)
+      ? milestone.hints
+      : (milestone.hints as any)?.[difficultyMode] || [];
+
+    const prompt = `The user is stuck on Milestone ${milestoneNumber} ("${
+      milestone.title
+    }") of the project "${milestone.project.title}".
+    Milestone description: ${milestone.description}.
+    Difficulty Mode: ${difficultyMode}.
+    ${modeInstruction}
+    Existing hints: ${modeHintsForPrompt.join(", ")}.
+    Please provide a new, progressive hint that helps them move forward without revealing the full solution. 
+    Format the response as a single, clear hint string.`;
+
+    const hint = await getGeminiResponse(prompt);
+
+    // Persist the hint by mode in the JSON object
+    const existingHints = (milestone.hints as any) || {};
+    const modeHints = existingHints[difficultyMode] || [];
+    modeHints.push(hint);
+
+    await prisma.projectMilestone.update({
+      where: { id: milestone.id },
+      data: {
+        hints: {
+          ...existingHints,
+          [difficultyMode]: modeHints,
+        },
+      },
+    });
+
+    res.json({ success: true, data: hint });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getChatHistory = async (req: Request, res: Response) => {
+  const { projectId } = req.params;
+  const userId = (req as any).user?.id;
+
+  try {
+    const messages = await prisma.chatMessage.findMany({
+      where: {
+        userId,
+        projectId: projectId || null,
+      },
+      orderBy: { createdAt: "asc" },
+    });
+
+    res.json({ success: true, data: messages });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

controllers/analytics/index.ts

@@ -0,0 +1,72 @@
+import { Request, Response, NextFunction } from "express";
+import prisma from "../../prisma/client";
+
+export const getUserAnalytics = async (req: Request, res: Response, next: NextFunction) => {
+  const userId = (req as any).user?.id;
+
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      select: {
+        xp: true,
+        streak: true,
+        _count: {
+          select: {
+            projects: true,
+            submissions: true,
+            achievements: true
+          }
+        }
+      }
+    });
+
+    const projectCompletion = await prisma.userProject.groupBy({
+      by: ["status"],
+      where: { userId },
+      _count: true
+    });
+
+    res.json({
+      success: true,
+      data: {
+        stats: user,
+        projectCompletion
+      }
+    });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const getAdminAnalytics = async (req: Request, res: Response, next: NextFunction) => {
+  const userId = (req as any).user?.id;
+
+  try {
+    const user = await prisma.user.findUnique({ where: { id: userId } });
+    if (user?.role !== "ADMIN") {
+      return res.status(403).json({ success: false, message: "Forbidden" });
+    }
+
+    const totalUsers = await prisma.user.count();
+    const totalProjects = await prisma.project.count();
+    const totalSubmissions = await prisma.submission.count();
+    
+    const popularProjects = await prisma.project.findMany({
+      orderBy: { submissionCount: "desc" },
+      take: 5,
+      select: { title: true, submissionCount: true }
+    });
+
+    res.json({
+      success: true,
+      data: {
+        totalUsers,
+        totalProjects,
+        totalSubmissions,
+        popularProjects
+      }
+    });
+  } catch (error: any) {
+    next(error);
+  }
+};

controllers/auth/index.ts

@@ -0,0 +1,448 @@
+import { Request, Response } from "express";
+import prisma from "../../prisma/client";
+import * as argon2 from "argon2";
+import { sendEmail } from "../../middlewares/email";
+import { generateOTP } from "../../middlewares/generateOTP";
+import jwt from "jsonwebtoken";
+import dotenv from "dotenv";
+import redis from "../../utils/redis";
+import { Difficulty, Role } from "@prisma/client";
+
+dotenv.config();
+const JWT_SECRET: string = process.env.JWT_SECRET || "default_secret";
+
+export const signUp = async (req: Request, res: Response) => {
+  const { firstName, lastName, skillLevel, email, password, role } = req.body;
+  try {
+    const existingUser = await prisma.user.findUnique({ where: { email } });
+    if (existingUser) {
+      return res
+        .status(400)
+        .json({ success: false, message: "Email already registered" });
+    }
+
+    const hashedPassword = await argon2.hash(password);
+    const user = await prisma.user.create({
+      data: {
+        firstName,
+        lastName,
+        email,
+        skillLevel: (skillLevel as Difficulty) || "BEGINNER",
+        password: hashedPassword,
+        role: (role as Role) || "STUDENT",
+      },
+    });
+
+    res.json({
+      success: true,
+      message: "User registered successfully",
+      data: { id: user.id },
+    });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const login = async (req: Request, res: Response) => {
+  const { email, password } = req.body;
+  try {
+    const user = await prisma.user.findUnique({ where: { email } });
+    if (!user || !user.password) {
+      return res
+        .status(401)
+        .json({ success: false, message: "Invalid Email or Password" });
+    }
+
+    const verifyPassword = await argon2.verify(user.password, password);
+    if (!verifyPassword) {
+      return res
+        .status(401)
+        .json({ success: false, message: "Invalid Email or Password" });
+    }
+
+    const token = jwt.sign({ id: user.id, role: user.role }, JWT_SECRET, {
+      expiresIn: "7d",
+    });
+
+    res.cookie("token", token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict",
+      maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days
+    });
+
+    res.json({
+      success: true,
+      message: "Login successful",
+      data: {
+        id: user.id,
+        firstName: user.firstName,
+        lastName: user.lastName,
+        email: user.email,
+        role: user.role,
+        token,
+      },
+    });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const logout = async (req: Request, res: Response) => {
+  res.clearCookie("token");
+  res.json({ success: true, message: "Logged out successfully" });
+};
+
+export const me = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  if (!userId) {
+    return res.status(401).json({ success: false, message: "Unauthorized" });
+  }
+
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      select: {
+        id: true,
+        email: true,
+        firstName: true,
+        lastName: true,
+        skillLevel: true,
+        bio: true,
+        portfolioLinks: true,
+        xp: true,
+        streak: true,
+        role: true,
+        avatarUrl: true,
+        createdAt: true,
+        projects: {
+          include: {
+            project: true,
+          },
+        },
+        achievements: {
+          include: {
+            achievement: true,
+          },
+        },
+      },
+    });
+
+    if (!user) {
+      return res
+        .status(404)
+        .json({ success: false, message: "User not found" });
+    }
+
+    res.json({ success: true, data: user });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const forgetPassword = async (req: Request, res: Response) => {
+  const { email } = req.body;
+  const appName = "Dev Drill";
+
+  try {
+    const user = await prisma.user.findUnique({ where: { email } });
+    if (!user) {
+      return res
+        .status(404)
+        .json({ success: false, message: "Account is not registered" });
+    }
+
+    const { otp, otpDate } = generateOTP();
+    // Store OTP in Redis with 1 hour expiry
+    await redis.setex(`otp:${email}`, 3600, otp.toString());
+
+    const htmlMessage = `
+      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+        <div style="background: #f0f7ff; padding: 30px; border-radius: 10px;">
+          <h1 style="color: #1a237e; margin-bottom: 25px;">${appName}</h1>
+          <p style="font-size: 16px; color: #333;">
+            Hello ${user.lastName},<br><br>
+            We received a request to reset your password for your ${appName} account.
+          </p>
+          <div style="background: #fff; padding: 20px; border-radius: 5px; margin: 20px 0; text-align: center;">
+            <p style="margin: 0; font-weight: bold; font-size: 24px; letter-spacing: 2px;">${otp}</p>
+          </div>
+          <p style="font-size: 14px; color: #666;">
+            This verification code will expire in 1 hour.<br>
+            If you didn't request this password reset, please ignore this email.
+          </p>
+        </div>
+        <p style="font-size: 12px; color: #999; text-align: center; margin-top: 20px;">
+          © ${new Date().getFullYear()} ${appName}. All rights reserved.
+        </p>
+      </div>
+    `;
+
+    const textMessage =
+      `${appName} Password Reset\n\n` +
+      `Hello ${user.lastName},\n\n` +
+      `Use this OTP to reset your password: ${otp}\n` +
+      `This code expires in 1 hour.`;
+
+    sendEmail(
+      user.email,
+      `Password Reset Request - ${appName}`,
+      htmlMessage,
+      textMessage
+    );
+
+    res.json({
+      success: true,
+      message: `An OTP has been sent to your mail. Check your mail for your verification code`,
+    });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const verifyOTP = async (req: Request, res: Response) => {
+  const { email, otp: userOtp } = req.body;
+
+  try {
+    const storedOtp = await redis.get(`otp:${email}`);
+    if (!storedOtp) {
+      return res
+        .status(400)
+        .json({ success: false, message: "OTP expired or not found" });
+    }
+
+    if (storedOtp !== userOtp.toString()) {
+      return res
+        .status(400)
+        .json({ success: false, message: "Invalid Verification code!" });
+    }
+
+    // OTP verified, can remove it now
+    await redis.del(`otp:${email}`);
+    // Optionally set a flag in Redis that OTP was verified for this email to allow password reset
+    await redis.setex(`otp_verified:${email}`, 600, "true");
+
+    res.json({ success: true, message: "Verification successful" });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const resetPassword = async (req: Request, res: Response) => {
+  const { email, newPassword } = req.body;
+
+  try {
+    const isVerified = await redis.get(`otp_verified:${email}`);
+    if (!isVerified) {
+      return res
+        .status(400)
+        .json({ success: false, message: "OTP not verified" });
+    }
+
+    const user = await prisma.user.findUnique({ where: { email } });
+    if (!user)
+      return res
+        .status(404)
+        .json({ success: false, message: "User not found" });
+
+    if (user.password) {
+      const verifyPassword = await argon2.verify(user.password, newPassword);
+      if (verifyPassword) {
+        return res
+          .status(400)
+          .json({ success: false, message: "You entered your old password" });
+      }
+    }
+
+    const newPass = await argon2.hash(newPassword);
+    await prisma.user.update({
+      where: { email },
+      data: { password: newPass },
+    });
+
+    await redis.del(`otp_verified:${email}`);
+
+    res.json({ success: true, message: "Password successfully reset" });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getUser = async (req: Request, res: Response) => {
+  const { id } = req.params;
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id },
+      select: {
+        id: true,
+        email: true,
+        firstName: true,
+        lastName: true,
+        skillLevel: true,
+        bio: true,
+        portfolioLinks: true,
+        xp: true,
+        streak: true,
+        role: true,
+        avatarUrl: true,
+        createdAt: true,
+        projects: {
+          include: {
+            project: true,
+          },
+        },
+        achievements: {
+          include: {
+            achievement: true,
+          },
+        },
+      },
+    });
+    if (!user)
+      return res
+        .status(404)
+        .json({ success: false, message: "User not found" });
+    res.json({ success: true, data: user });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const updateUser = async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const authenticatedUserId = (req as any).user?.id;
+
+  if (authenticatedUserId !== id) {
+    return res.status(403).json({ success: false, message: "Forbidden" });
+  }
+
+  let {
+    firstName,
+    lastName,
+    email,
+    password,
+    bio,
+    skillLevel,
+    portfolioLinks,
+    avatarUrl,
+  } = req.body;
+  try {
+    const user = await prisma.user.findUnique({ where: { id } });
+    if (!user) {
+      return res
+        .status(404)
+        .json({ success: false, message: "User not found" });
+    }
+
+    const data: any = {
+      firstName,
+      lastName,
+      bio,
+      skillLevel,
+      portfolioLinks,
+      avatarUrl,
+    };
+
+    if (email && email !== user.email) {
+      const existingUser = await prisma.user.findUnique({ where: { email } });
+      if (existingUser) {
+        return res
+          .status(400)
+          .json({ success: false, message: "Email already in use" });
+      }
+      data.email = email;
+    }
+
+    if (password) {
+      data.password = await argon2.hash(password);
+    }
+
+    const updatedUser = await prisma.user.update({
+      where: { id },
+      data,
+      select: {
+        id: true,
+        email: true,
+        firstName: true,
+        lastName: true,
+        skillLevel: true,
+        bio: true,
+        portfolioLinks: true,
+        xp: true,
+        streak: true,
+        role: true,
+        avatarUrl: true,
+        createdAt: true,
+        projects: {
+          include: {
+            project: true,
+          },
+        },
+        achievements: {
+          include: {
+            achievement: true,
+          },
+        },
+      },
+    });
+
+    res.json({
+      success: true,
+      data: updatedUser,
+    });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const googleAuthCallback = async (req: Request, res: Response) => {
+  try {
+    const user = req.user as any;
+    if (!user) {
+      return res.redirect(
+        `${process.env.CLIENT_URL}/auth/signin?error=auth_failed`
+      );
+    }
+
+    const token = jwt.sign({ id: user.id, role: user.role }, JWT_SECRET, {
+      expiresIn: "7d",
+    });
+
+    res.cookie("token", token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      maxAge: 7 * 24 * 60 * 60 * 1000,
+    });
+
+    res.redirect(`${process.env.CLIENT_URL}/dashboard`);
+  } catch (error: any) {
+    res.redirect(`${process.env.CLIENT_URL}/auth/signin?error=server_error`);
+  }
+};
+
+export const githubAuthCallback = async (req: Request, res: Response) => {
+  try {
+    const user = req.user as any;
+    if (!user) {
+      return res.redirect(
+        `${process.env.CLIENT_URL}/auth/signin?error=auth_failed`
+      );
+    }
+
+    const token = jwt.sign({ id: user.id, role: user.role }, JWT_SECRET, {
+      expiresIn: "7d",
+    });
+
+    res.cookie("token", token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      maxAge: 7 * 24 * 60 * 60 * 1000,
+    });
+
+    res.redirect(`${process.env.CLIENT_URL}/dashboard`);
+  } catch (error: any) {
+    res.redirect(`${process.env.CLIENT_URL}/auth/signin?error=server_error`);
+  }
+};

controllers/code-review/index.ts

@@ -0,0 +1,71 @@
+import { Request, Response } from "express";
+import prisma from "../../prisma/client";
+import { getGeminiResponse } from "../../utils/gemini";
+import axios from "axios";
+
+export const analyzeCode = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { repoUrl, projectId } = req.body;
+
+  try {
+    // 1. Fetch code from GitHub (simplified: fetch README or a few files for demo)
+    // In a real app, you'd use a GitHub App or User Token to clone or fetch via API
+    const repoPath = repoUrl.replace("https://github.com/", "");
+    const [owner, repo] = repoPath.split("/");
+
+    // Fetch repo info as a placeholder for analysis
+    const githubApiUrl = `https://api.github.com/repos/${owner}/${repo}`;
+    const repoInfo = await axios.get(githubApiUrl);
+
+    // 2. Automated analysis (simulated)
+    const metrics = {
+      complexity: "Medium",
+      securityIssues: 0,
+      lintErrors: 0
+    };
+
+    // 3. AI-powered feedback
+    const prompt = `Please review this GitHub repository: ${repoUrl}.
+    Owner: ${owner}
+    Repo: ${repo}
+    Description: ${repoInfo.data.description}
+    Provide constructive feedback on the project structure and suggest improvements for a student.`;
+
+    const feedback = await getGeminiResponse(prompt);
+
+    // 4. Store review results
+    const submission = await prisma.submission.create({
+      data: {
+        userId,
+        projectId,
+        repoUrl,
+        feedback,
+        score: 85 // Simulated score
+      }
+    });
+
+    res.json({ success: true, data: submission });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getSubmissionReview = async (req: Request, res: Response) => {
+  const { id } = req.params;
+
+  try {
+    const submission = await prisma.submission.findUnique({
+      where: { id },
+      include: {
+        project: { select: { title: true } },
+        user: { select: { firstName: true, lastName: true } }
+      }
+    });
+
+    if (!submission) return res.status(404).json({ success: false, message: "Submission not found" });
+
+    res.json({ success: true, data: submission });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

controllers/community/index.ts

@@ -0,0 +1,152 @@
+import { Request, Response, NextFunction } from "express";
+import prisma from "../../prisma/client";
+
+export const getPublicSubmissions = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const submissions = await prisma.submission.findMany({
+      where: { isPublic: true },
+      include: {
+        user: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            avatarUrl: true,
+          },
+        },
+        project: {
+          select: {
+            id: true,
+            title: true,
+          },
+        },
+        _count: {
+          select: {
+            comments: true,
+            votes: true,
+          },
+        },
+      },
+      orderBy: { createdAt: "desc" },
+    });
+
+    res.json({ success: true, data: submissions });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const commentOnSubmission = async (req: Request, res: Response, next: NextFunction) => {
+  const { id: submissionId } = req.params;
+  const { content } = req.body;
+  const userId = (req as any).user?.id;
+
+  try {
+    const comment = await prisma.comment.create({
+      data: {
+        content,
+        userId,
+        submissionId,
+      },
+      include: {
+        user: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            avatarUrl: true,
+          },
+        },
+      },
+    });
+
+    res.status(201).json({ success: true, data: comment });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const voteOnSubmission = async (req: Request, res: Response, next: NextFunction) => {
+  const { id: submissionId } = req.params;
+  const { value } = req.body; // 1 for upvote, -1 for downvote
+  const userId = (req as any).user?.id;
+
+  try {
+    const vote = await prisma.vote.upsert({
+      where: {
+        userId_submissionId: {
+          userId,
+          submissionId,
+        },
+      },
+      update: { value },
+      create: {
+        value,
+        userId,
+        submissionId,
+      },
+    });
+
+    res.json({ success: true, data: vote });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const getForumThreads = async (req: Request, res: Response, next: NextFunction) => {
+  const { projectId } = req.query;
+
+  try {
+    const threads = await prisma.forumThread.findMany({
+      where: projectId ? { projectId: String(projectId) } : {},
+      include: {
+        user: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            avatarUrl: true,
+          },
+        },
+        _count: {
+          select: { posts: true },
+        },
+      },
+      orderBy: { createdAt: "desc" },
+    });
+
+    res.json({ success: true, data: threads });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const createForumThread = async (req: Request, res: Response, next: NextFunction) => {
+  const { title, content, projectId } = req.body;
+  const userId = (req as any).user?.id;
+
+  try {
+    const thread = await prisma.forumThread.create({
+      data: {
+        title,
+        content,
+        userId,
+        projectId: projectId || null,
+      },
+      include: {
+        user: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            avatarUrl: true,
+          },
+        },
+      },
+    });
+
+    res.status(201).json({ success: true, data: thread });
+  } catch (error: any) {
+    next(error);
+  }
+};

controllers/events/index.ts

@@ -0,0 +1,221 @@
+import { Request, Response } from "express";
+import prisma from "../../prisma/client";
+import { EventStatus } from "@prisma/client";
+
+export const createEvent = async (req: Request, res: Response) => {
+  const {
+    title,
+    description,
+    type,
+    startDate,
+    endDate,
+    prizePool,
+    maxParticipants,
+    bannerUrl,
+  } = req.body;
+
+  try {
+    const event = await prisma.event.create({
+      data: {
+        title,
+        description,
+        type,
+        startDate: new Date(startDate),
+        endDate: new Date(endDate),
+        prizePool,
+        maxParticipants,
+        bannerUrl,
+      },
+    });
+
+    res.json({ success: true, data: event });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getEvents = async (req: Request, res: Response) => {
+  const { status, type, page = 1, limit = 10 } = req.query;
+
+  try {
+    const where: any = {};
+    if (status) where.status = status as EventStatus;
+    if (type) where.type = type;
+
+    const events = await prisma.event.findMany({
+      where,
+      include: {
+        _count: {
+          select: { participants: true },
+        },
+      },
+      orderBy: { startDate: "desc" },
+      take: Number(limit),
+      skip: (Number(page) - 1) * Number(limit),
+    });
+
+    res.json({ success: true, data: events });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getEvent = async (req: Request, res: Response) => {
+  const { id } = req.params;
+
+  try {
+    const event = await prisma.event.findUnique({
+      where: { id },
+      include: {
+        participants: {
+          include: {
+            user: {
+              select: {
+                id: true,
+                firstName: true,
+                lastName: true,
+                avatarUrl: true,
+              },
+            },
+          },
+        },
+        leaderboard: {
+          include: {
+            user: {
+              select: {
+                id: true,
+                firstName: true,
+                lastName: true,
+                avatarUrl: true,
+              },
+            },
+          },
+          orderBy: { score: "desc" },
+          take: 100,
+        },
+      },
+    });
+
+    if (!event) {
+      return res
+        .status(404)
+        .json({ success: false, message: "Event not found" });
+    }
+
+    res.json({ success: true, data: event });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const joinEvent = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { eventId } = req.params;
+
+  try {
+    const event = await prisma.event.findUnique({
+      where: { id: eventId },
+      include: { _count: { select: { participants: true } } },
+    });
+
+    if (!event) {
+      return res
+        .status(404)
+        .json({ success: false, message: "Event not found" });
+    }
+
+    if (
+      event.maxParticipants &&
+      event._count.participants >= event.maxParticipants
+    ) {
+      return res.status(400).json({ success: false, message: "Event is full" });
+    }
+
+    const participant = await prisma.eventParticipant.create({
+      data: { eventId, userId },
+    });
+
+    await prisma.eventLeaderboard.create({
+      data: { eventId, userId, score: 0 },
+    });
+
+    res.json({ success: true, data: participant });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const leaveEvent = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { eventId } = req.params;
+
+  try {
+    await prisma.eventParticipant.delete({
+      where: { eventId_userId: { eventId, userId } },
+    });
+
+    await prisma.eventLeaderboard.delete({
+      where: { eventId_userId: { eventId, userId } },
+    });
+
+    res.json({ success: true, message: "Left event successfully" });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const updateEventScore = async (req: Request, res: Response) => {
+  const { eventId, userId } = req.params;
+  const { score } = req.body;
+
+  try {
+    const leaderboard = await prisma.eventLeaderboard.update({
+      where: { eventId_userId: { eventId, userId } },
+      data: { score },
+    });
+
+    const allScores = await prisma.eventLeaderboard.findMany({
+      where: { eventId },
+      orderBy: { score: "desc" },
+    });
+
+    for (let i = 0; i < allScores.length; i++) {
+      await prisma.eventLeaderboard.update({
+        where: { id: allScores[i].id },
+        data: { rank: i + 1 },
+      });
+    }
+
+    res.json({ success: true, data: leaderboard });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getLeaderboard = async (req: Request, res: Response) => {
+  const { eventId } = req.params;
+  const { limit = 100 } = req.query;
+
+  try {
+    const leaderboard = await prisma.eventLeaderboard.findMany({
+      where: { eventId },
+      include: {
+        user: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            avatarUrl: true,
+            xp: true,
+          },
+        },
+      },
+      orderBy: { score: "desc" },
+      take: Number(limit),
+    });
+
+    res.json({ success: true, data: leaderboard });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

controllers/gamification/index.ts

@@ -0,0 +1,69 @@
+import { Request, Response, NextFunction } from "express";
+import prisma from "../../prisma/client";
+import redis from "../../utils/redis";
+
+const LEADERBOARD_CACHE_KEY = "leaderboard:top20";
+const CACHE_TTL = 3600; // 1 hour
+
+export const getLeaderboard = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    // Try to get from cache
+    const cachedLeaderboard = await redis.get(LEADERBOARD_CACHE_KEY);
+    if (cachedLeaderboard) {
+      return res.json({ success: true, data: JSON.parse(cachedLeaderboard), cached: true });
+    }
+
+    const leaderboard = await prisma.user.findMany({
+      select: {
+        id: true,
+        firstName: true,
+        lastName: true,
+        avatarUrl: true,
+        xp: true,
+        streak: true
+      },
+      orderBy: { xp: "desc" },
+      take: 20
+    });
+
+    // Save to cache
+    await redis.setex(LEADERBOARD_CACHE_KEY, CACHE_TTL, JSON.stringify(leaderboard));
+
+    res.json({ success: true, data: leaderboard });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const getUserAchievements = async (req: Request, res: Response, next: NextFunction) => {
+  const userId = (req as any).user?.id;
+
+  try {
+    const achievements = await prisma.userAchievement.findMany({
+      where: { userId },
+      include: {
+        achievement: true
+      }
+    });
+
+    res.json({ success: true, data: achievements });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const awardXP = async (userId: string, amount: number) => {
+  try {
+    await prisma.user.update({
+      where: { id: userId },
+      data: {
+        xp: { increment: amount }
+      }
+    });
+    
+    // Invalidate leaderboard cache when XP changes
+    await redis.del(LEADERBOARD_CACHE_KEY);
+  } catch (error) {
+    console.error("Error awarding XP:", error);
+  }
+};

controllers/github/index.ts

@@ -0,0 +1,109 @@
+import { Request, Response } from "express";
+import prisma from "../../prisma/client";
+import axios from "axios";
+
+export const linkRepository = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { projectId, repoUrl } = req.body;
+
+  try {
+    if (!repoUrl.includes("github.com")) {
+      return res.status(400).json({
+        success: false,
+        message: "Invalid GitHub repository URL",
+      });
+    }
+
+    // Extract owner and repo from URL
+    const repoPath = repoUrl
+      .replace("https://github.com/", "")
+      .replace(".git", "");
+    const [owner, repo] = repoPath.split("/");
+
+    // Verify repository exists (optional - requires GitHub token)
+    try {
+      const githubApiUrl = `https://api.github.com/repos/${owner}/${repo}`;
+      await axios.get(githubApiUrl);
+    } catch (error) {
+      return res.status(404).json({
+        success: false,
+        message: "Repository not found or not accessible",
+      });
+    }
+
+    // Update user project with repo URL
+    const userProject = await prisma.userProject.findFirst({
+      where: {
+        userId,
+        projectId,
+      },
+    });
+
+    if (!userProject) {
+      return res.status(404).json({
+        success: false,
+        message: "Project not started by user",
+      });
+    }
+
+    const updated = await prisma.userProject.update({
+      where: { id: userProject.id },
+      data: { repoUrl },
+    });
+
+    res.json({ success: true, data: updated });
+  } catch (error: any) {
+    console.error("Link repository error:", error);
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getRepositoryCommits = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { projectId } = req.params;
+
+  try {
+    const userProject = await prisma.userProject.findFirst({
+      where: {
+        userId,
+        projectId,
+      },
+    });
+
+    if (!userProject || !userProject.repoUrl) {
+      return res.status(404).json({
+        success: false,
+        message: "No repository linked",
+      });
+    }
+
+    // Extract owner and repo
+    const repoPath = userProject.repoUrl
+      .replace("https://github.com/", "")
+      .replace(".git", "");
+    const [owner, repo] = repoPath.split("/");
+
+    // Fetch commits from GitHub API
+    const githubApiUrl = `https://api.github.com/repos/${owner}/${repo}/commits`;
+    const response = await axios.get(githubApiUrl, {
+      params: { per_page: 10 },
+      headers: {
+        // Add GitHub token if available for higher rate limits
+        Authorization: `token ${process.env.GITHUB_TOKEN}`,
+      },
+    });
+
+    const commits = response.data.map((commit: any) => ({
+      id: commit.sha,
+      message: commit.commit.message,
+      author: commit.commit.author.name,
+      date: commit.commit.author.date,
+      url: commit.html_url,
+    }));
+
+    res.json({ success: true, data: commits });
+  } catch (error: any) {
+    console.error("Get commits error:", error);
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

controllers/notifications/index.ts

@@ -0,0 +1,75 @@
+import { Request, Response } from "express";
+import prisma from "../../prisma/client";
+
+export const getNotifications = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { page = 1, limit = 20, unreadOnly = false } = req.query;
+
+  try {
+    const where: any = { userId };
+    if (unreadOnly === "true") {
+      where.read = false;
+    }
+
+    const notifications = await prisma.notification.findMany({
+      where,
+      orderBy: { createdAt: "desc" },
+      take: Number(limit),
+      skip: (Number(page) - 1) * Number(limit),
+    });
+
+    const unreadCount = await prisma.notification.count({
+      where: { userId, read: false },
+    });
+
+    res.json({ success: true, data: { notifications, unreadCount } });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const markAsRead = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { notificationId } = req.params;
+
+  try {
+    await prisma.notification.updateMany({
+      where: { id: notificationId, userId },
+      data: { read: true },
+    });
+
+    res.json({ success: true, message: "Notification marked as read" });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const markAllAsRead = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+
+  try {
+    await prisma.notification.updateMany({
+      where: { userId, read: false },
+      data: { read: true },
+    });
+
+    res.json({ success: true, message: "All notifications marked as read" });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const deleteNotification = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { notificationId } = req.params;
+
+  try {
+    await prisma.notification.deleteMany({
+      where: { id: notificationId, userId },
+    });
+
+    res.json({ success: true, message: "Notification deleted" });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

controllers/paths/index.ts

@@ -0,0 +1,82 @@
+import { Request, Response, NextFunction } from "express";
+import prisma from "../../prisma/client";
+
+export const getLearningPaths = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const paths = await prisma.learningPath.findMany({
+      include: {
+        projects: {
+          include: {
+            project: {
+              select: {
+                title: true,
+                difficultyLevel: true,
+              },
+            },
+          },
+          orderBy: { orderIndex: "asc" },
+        },
+      },
+    });
+
+    res.json({ success: true, data: paths });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const getPathProgress = async (req: Request, res: Response, next: NextFunction) => {
+  const { id: pathId } = req.params;
+  const userId = (req as any).user?.id;
+
+  try {
+    const progress = await prisma.userPathProgress.findUnique({
+      where: {
+        userId_pathId: {
+          userId,
+          pathId,
+        },
+      },
+      include: {
+        path: {
+          include: {
+            projects: {
+              include: { project: true },
+              orderBy: { orderIndex: "asc" },
+            },
+          },
+        },
+      },
+    });
+
+    res.json({ success: true, data: progress });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const startPath = async (req: Request, res: Response, next: NextFunction) => {
+  const { id: pathId } = req.params;
+  const userId = (req as any).user?.id;
+
+  try {
+    const progress = await prisma.userPathProgress.upsert({
+      where: {
+        userId_pathId: {
+          userId,
+          pathId
+        }
+      },
+      update: {},
+      create: {
+        userId,
+        pathId,
+        currentProjectIndex: 0,
+      },
+    });
+
+    res.status(201).json({ success: true, data: progress });
+  } catch (error: any) {
+    next(error);
+  }
+};

controllers/projects/index.ts

@@ -0,0 +1,706 @@
+import { Request, Response } from "express";
+import prisma from "../../prisma/client";
+import { Difficulty, DifficultyMode, ProjectStatus } from "@prisma/client";
+import { checkAuth } from "../../middlewares/auth";
+import { upLoadFiles, uploadBuffer } from "../../middlewares/file";
+import { generateSlug, parseIfString } from "../../utils/helper";
+import { getGeminiResponse } from "../../utils/gemini";
+
+export const createProject = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  let {
+    title,
+    description,
+    difficultyLevel,
+    technologies,
+    categories,
+    estimatedTime,
+    learningObjectives,
+    resourceLinks,
+    starterRepoUrl,
+    difficultyModes,
+    coverImage,
+    milestones,
+  } = req.body;
+
+  // Parse JSON strings from FormData
+  technologies = parseIfString(technologies);
+  categories = parseIfString(categories);
+  learningObjectives = parseIfString(learningObjectives);
+  resourceLinks = parseIfString(resourceLinks);
+  difficultyModes = parseIfString(difficultyModes);
+  milestones = parseIfString(milestones);
+
+  try {
+    if (!userId)
+      return res.status(401).json({ success: false, message: "Unauthorized" });
+
+    const user = await prisma.user.findUnique({ where: { id: userId } });
+    if (!user || (user.role !== "ADMIN" && user.role !== "CONTRIBUTOR")) {
+      return res.status(403).json({
+        success: false,
+        message: "Only Admins or Contributors can create projects",
+      });
+    }
+
+    let imageUrl = coverImage;
+    if (req.file) {
+      imageUrl = await uploadBuffer(req.file.buffer, req.file.originalname);
+    } else if (coverImage && !coverImage.startsWith("http")) {
+      imageUrl = await upLoadFiles(coverImage);
+    }
+
+    const project = await prisma.project.create({
+      data: {
+        title,
+        slug: generateSlug(title),
+        description,
+        difficultyLevel: difficultyLevel as Difficulty,
+        technologies,
+        categories,
+        estimatedTime,
+        learningObjectives,
+        resourceLinks: resourceLinks || [],
+        starterRepoUrl,
+        difficultyModes: difficultyModes || ["GUIDED", "STANDARD", "HARDCORE"],
+        createdBy: { connect: { id: userId } },
+        coverImage: imageUrl,
+        milestones: {
+          create: milestones?.map((m: any, index: number) => ({
+            milestoneNumber: index + 1,
+            title: m.title,
+            description: m.description,
+            hints: Array.isArray(m.hints) ? { GUIDED: m.hints } : m.hints || {},
+            validationCriteria: m.validationCriteria,
+          })),
+        },
+      },
+      include: { milestones: true },
+    });
+
+    res.status(201).json({ success: true, data: project });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const updateProject = async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const userId = (req as any).user?.id;
+
+  let updateData = req.body;
+
+  updateData.technologies = parseIfString(updateData.technologies);
+  updateData.categories = parseIfString(updateData.categories);
+  updateData.learningObjectives = parseIfString(updateData.learningObjectives);
+  updateData.resourceLinks = parseIfString(updateData.resourceLinks);
+  updateData.difficultyModes = parseIfString(updateData.difficultyModes);
+
+  const milestonesData = parseIfString(updateData.milestones);
+  delete updateData.milestones;
+
+  try {
+    const project = await prisma.project.findUnique({
+      where: { id },
+      include: { milestones: true, userProjects: true },
+    });
+
+    if (!project) {
+      return res.status(404).json({
+        success: false,
+        message: "Project not found",
+      });
+    }
+
+    const user = await prisma.user.findUnique({ where: { id: userId } });
+
+    if (!user || (user.role !== "ADMIN" && project.createdById !== userId)) {
+      return res.status(403).json({
+        success: false,
+        message: "Unauthorized to update this project",
+      });
+    }
+
+    if (req.file) {
+      updateData.coverImage = await uploadBuffer(
+        req.file.buffer,
+        req.file.originalname
+      );
+    } else if (
+      updateData.coverImage &&
+      !updateData.coverImage.startsWith("http")
+    ) {
+      updateData.coverImage = await upLoadFiles(updateData.coverImage);
+    }
+
+    // Update slug if title changed
+    if (updateData.title && updateData.title !== project.title) {
+      updateData.slug = generateSlug(updateData.title);
+    }
+
+    // Clean up any undefined or empty string values
+    Object.keys(updateData).forEach((key) => {
+      if (updateData[key] === undefined || updateData[key] === "") {
+        delete updateData[key];
+      }
+    });
+
+    // Update project with milestones handled separately
+    const updatedProject = await prisma.project.update({
+      where: { id },
+      data: {
+        ...updateData,
+        ...(milestonesData && {
+          milestones: {
+            deleteMany: {},
+            create: milestonesData
+              .filter((m: any) => m.title && m.description)
+              .map((m: any, index: number) => ({
+                milestoneNumber: index + 1,
+                title: m.title,
+                description: m.description,
+                hints: typeof m.hints === "object" ? m.hints : {},
+                validationCriteria:
+                  typeof m.validationCriteria === "string"
+                    ? m.validationCriteria
+                    : JSON.stringify(m.validationCriteria || {}),
+              })),
+          },
+        }),
+      },
+      include: {
+        milestones: {
+          orderBy: { milestoneNumber: "asc" },
+        },
+        createdBy: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            email: true,
+            avatarUrl: true,
+          },
+        },
+        userProjects: { where: { userId: user.id } },
+      },
+    });
+
+    // Build progressByMode
+    let progressByMode: any = {};
+    let userProgress = null;
+
+    if (updatedProject.userProjects && updatedProject.userProjects.length > 0) {
+      for (const up of updatedProject.userProjects) {
+        const completedMilestones = await prisma.userMilestone.findMany({
+          where: {
+            userId: user.id,
+            userProjectId: up.id,
+          },
+          select: { milestoneId: true },
+        });
+
+        progressByMode[up.difficultyModeChosen] = {
+          status: up.status,
+          completedMilestones: completedMilestones.map((m) => m.milestoneId),
+          userProjectId: up.id,
+          startedAt: up.startedAt,
+          completedAt: up.completedAt,
+        };
+      }
+
+      userProgress =
+        updatedProject.userProjects[updatedProject.userProjects.length - 1];
+    }
+
+    res.json({
+      success: true,
+      data: {
+        ...updatedProject,
+        progressByMode,
+        userProgress,
+      },
+    });
+  } catch (error: any) {
+    console.error("Update project error:", error);
+    res.status(500).json({
+      success: false,
+      message: error.message,
+    });
+  }
+};
+
+export const deleteProject = async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const userId = (req as any).user?.id;
+
+  try {
+    const project = await prisma.project.findUnique({ where: { id } });
+    if (!project)
+      return res
+        .status(404)
+        .json({ success: false, message: "Project not found" });
+
+    const user = await prisma.user.findUnique({ where: { id: userId } });
+    if (!user || user.role !== "ADMIN") {
+      return res
+        .status(403)
+        .json({ success: false, message: "Only Admins can delete projects" });
+    }
+
+    await prisma.project.delete({ where: { id } });
+    res.json({ success: true, message: "Project deleted successfully" });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getProjects = async (req: Request, res: Response) => {
+  const { difficulty, tech, category, title } = req.query;
+
+  try {
+    const where: any = {};
+    if (difficulty) where.difficultyLevel = difficulty as Difficulty;
+    if (tech) where.technologies = { has: tech as string };
+    if (category) where.categories = { has: category as string };
+    if (title) where.title = { contains: title as string, mode: "insensitive" };
+
+    const projects = await prisma.project.findMany({
+      where,
+      include: {
+        createdBy: {
+          select: { firstName: true, lastName: true },
+        },
+      },
+      orderBy: { createdAt: "desc" },
+    });
+
+    res.json({ success: true, data: projects });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getProjectById = async (req: Request, res: Response) => {
+  const { id } = req.params;
+
+  try {
+    const user = await checkAuth(req);
+    const project = await prisma.project.findUnique({
+      where: { id },
+      include: {
+        milestones: { orderBy: { milestoneNumber: "asc" } },
+        createdBy: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            avatarUrl: true,
+          },
+        },
+        userProjects: user ? { where: { userId: user.id } } : false,
+      },
+    });
+
+    if (!project)
+      return res
+        .status(404)
+        .json({ success: false, message: "Project not found" });
+
+    // If user is authenticated, fetch their progress and completed milestones for each mode
+    let progressByMode: any = {};
+    let userProgress = null;
+
+    if (user && project.userProjects && project.userProjects.length > 0) {
+      for (const up of project.userProjects) {
+        const completedMilestones = await prisma.userMilestone.findMany({
+          where: {
+            userId: user.id,
+            userProjectId: up.id,
+          },
+          select: { milestoneId: true },
+        });
+
+        progressByMode[up.difficultyModeChosen] = {
+          status: up.status,
+          completedMilestones: completedMilestones.map((m) => m.milestoneId),
+          userProjectId: up.id,
+          startedAt: up.startedAt,
+          completedAt: up.completedAt,
+        };
+      }
+
+      // Set the most recent userProject as the default userProgress
+      userProgress = project.userProjects[project.userProjects.length - 1];
+    }
+
+    res.json({
+      success: true,
+      data: {
+        ...project,
+        progressByMode,
+        userProgress,
+      },
+    });
+  } catch (error: any) {
+    console.error("Get project error:", error);
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+// User Progress Endpoints
+export const startProject = async (req: Request, res: Response) => {
+  const { id: projectId } = req.params;
+  const userId = (req as any).user?.id;
+  const { difficultyModeChosen } = req.body;
+
+  try {
+    const mode = (difficultyModeChosen as DifficultyMode) || "STANDARD";
+
+    const existingProgress = await prisma.userProject.findUnique({
+      where: {
+        userId_projectId_difficultyModeChosen: {
+          userId,
+          projectId,
+          difficultyModeChosen: mode,
+        },
+      },
+    });
+
+    if (existingProgress) {
+      return res.status(400).json({
+        success: false,
+        message: "Project already started in this mode",
+      });
+    }
+
+    const progress = await prisma.userProject.create({
+      data: {
+        userId,
+        projectId,
+        difficultyModeChosen: mode,
+        status: "IN_PROGRESS",
+      },
+    });
+
+    res.status(201).json({ success: true, data: progress });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const updateProgress = async (req: Request, res: Response) => {
+  const { id: projectId } = req.params;
+  const userId = (req as any).user?.id;
+  const { status, repoUrl, difficultyMode } = req.body;
+
+  try {
+    const progress = await prisma.userProject.update({
+      where: {
+        userId_projectId_difficultyModeChosen: {
+          userId,
+          projectId,
+          difficultyModeChosen: difficultyMode as DifficultyMode,
+        },
+      },
+      data: { status: status as ProjectStatus, repoUrl },
+    });
+
+    res.json({ success: true, data: progress });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const completeProject = async (req: Request, res: Response) => {
+  const { id: projectId } = req.params;
+  const userId = (req as any).user?.id;
+  const { repoUrl, difficultyMode } = req.body;
+
+  try {
+    const progress = await prisma.userProject.update({
+      where: {
+        userId_projectId_difficultyModeChosen: {
+          userId,
+          projectId,
+          difficultyModeChosen: difficultyMode as DifficultyMode,
+        },
+      },
+      data: {
+        status: "COMPLETED",
+        completedAt: new Date(),
+        repoUrl,
+      },
+    });
+
+    // Award XP (simple example)
+    await prisma.user.update({
+      where: { id: userId },
+      data: { xp: { increment: 100 } },
+    });
+
+    // Update project completion rate
+    const totalStarted = await prisma.userProject.count({
+      where: { projectId },
+    });
+    const totalCompleted = await prisma.userProject.count({
+      where: { projectId, status: "COMPLETED" },
+    });
+
+    await prisma.project.update({
+      where: { id: projectId },
+      data: {
+        completionRate: (totalCompleted / totalStarted) * 100,
+        submissionCount: { increment: 1 },
+      },
+    });
+
+    res.json({ success: true, data: progress });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getUserProgress = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+
+  try {
+    const progress = await prisma.userProject.findMany({
+      where: { userId },
+      include: {
+        project: {
+          include: {
+            milestones: {
+              orderBy: { milestoneNumber: "asc" },
+            },
+            createdBy: {
+              select: { firstName: true, lastName: true, avatarUrl: true },
+            },
+          },
+        },
+        // Correct relation name from schema.prisma
+        milestoneProgress: {
+          select: { milestoneId: true, completedAt: true },
+        },
+      },
+    });
+
+    res.json({ success: true, data: progress });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+// Submissions
+export const submitProject = async (req: Request, res: Response) => {
+  const { id: projectId } = req.params;
+  const userId = (req as any).user?.id;
+  const { repoUrl } = req.body;
+
+  try {
+    const submission = await prisma.submission.create({
+      data: {
+        userId,
+        projectId,
+        repoUrl,
+      },
+    });
+
+    res.status(201).json({ success: true, data: submission });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const completeMilestone = async (req: Request, res: Response) => {
+  const { id: projectId, milestoneId } = req.params;
+  const userId = (req as any).user?.id;
+  const { difficultyMode } = req.body;
+
+  try {
+    const userProject = await prisma.userProject.findUnique({
+      where: {
+        userId_projectId_difficultyModeChosen: {
+          userId,
+          projectId,
+          difficultyModeChosen: difficultyMode as DifficultyMode,
+        },
+      },
+    });
+
+    if (!userProject) {
+      return res.status(400).json({
+        success: false,
+        message: "Project not started by user in this mode",
+      });
+    }
+
+    const existingMilestone = await prisma.userMilestone.findUnique({
+      where: {
+        userId_milestoneId_userProjectId: {
+          userId,
+          milestoneId,
+          userProjectId: userProject.id,
+        },
+      },
+    });
+
+    if (existingMilestone) {
+      return res.status(400).json({
+        success: false,
+        message: "Milestone already completed in this mode",
+      });
+    }
+
+    // 1. Create the milestone completion record
+    const milestone = await prisma.userMilestone.create({
+      data: {
+        userId,
+        milestoneId,
+        userProjectId: userProject.id,
+      },
+    });
+
+    // 2. CHECK FOR PROJECT COMPLETION
+    const totalMilestones = await prisma.projectMilestone.count({
+      where: { projectId },
+    });
+
+    const completedCount = await prisma.userMilestone.count({
+      where: {
+        userId,
+        userProjectId: userProject.id,
+      },
+    });
+
+    // 3. AUTO-COMPLETE PROJECT if all milestones are done
+    if (completedCount === totalMilestones) {
+      await prisma.userProject.update({
+        where: { id: userProject.id },
+        data: {
+          status: "COMPLETED",
+          completedAt: new Date(),
+        },
+      });
+
+      await prisma.user.update({
+        where: { id: userId },
+        data: { xp: { increment: 50 } },
+      });
+    }
+
+    res.status(201).json({ success: true, data: milestone });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getFeaturedProjects = async (req: Request, res: Response) => {
+  try {
+    const featuredProjects = await prisma.project.findMany({
+      take: 4,
+      orderBy: { submissionCount: "desc" },
+      include: {
+        createdBy: {
+          select: { firstName: true, lastName: true },
+        },
+      },
+    });
+
+    res.json({ success: true, data: featuredProjects });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const submitCode = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { projectId, milestoneId, code, language } = req.body;
+
+  try {
+    // Fetch milestone details for validation criteria
+    const milestone = await prisma.projectMilestone.findUnique({
+      where: { id: milestoneId },
+      include: { project: true },
+    });
+
+    if (!milestone) {
+      return res.status(404).json({
+        success: false,
+        message: "Milestone not found",
+      });
+    }
+
+    // AI-powered code review
+    const reviewPrompt = `
+You are a code reviewer for a learning platform. Review this code submission:
+
+Project: ${milestone.project.title}
+Milestone: ${milestone.title}
+Description: ${milestone.description}
+Validation Criteria: ${milestone.validationCriteria || "General best practices"}
+
+Code:
+\`\`\`${language}
+${code}
+\`\`\`
+
+Provide:
+1. Does this code meet the milestone requirements? (YES/NO)
+2. Code quality score (0-100)
+3. Specific feedback on what's good
+4. Areas for improvement
+5. Security concerns (if any)
+
+Format as JSON:
+{
+  "meetsRequirements": boolean,
+  "score": number,
+  "strengths": string[],
+  "improvements": string[],
+  "securityIssues": string[]
+}
+`;
+
+    const reviewResult = await getGeminiResponse(reviewPrompt);
+
+    // Parse AI response
+    let parsedReview;
+    try {
+      // Extract JSON from potential markdown code blocks
+      const jsonMatch = reviewResult.match(/```json\n?([\s\S]*?)\n?```/);
+      const jsonStr = jsonMatch ? jsonMatch[1] : reviewResult;
+      parsedReview = JSON.parse(jsonStr);
+    } catch (e) {
+      parsedReview = {
+        meetsRequirements: false,
+        score: 0,
+        strengths: [],
+        improvements: ["Unable to parse AI review"],
+        securityIssues: [],
+      };
+    }
+
+    // Save code submission
+    const submission = await prisma.submission.create({
+      data: {
+        userId,
+        projectId,
+        repoUrl: `code-submission-${Date.now()}`, // Placeholder
+        feedback: JSON.stringify(parsedReview),
+        score: parsedReview.score,
+        aiReviewData: parsedReview,
+      },
+    });
+
+    res.json({
+      success: true,
+      data: {
+        submission,
+        review: parsedReview,
+      },
+    });
+  } catch (error: any) {
+    console.error("Code submission error:", error);
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

controllers/social/index.ts

@@ -0,0 +1,187 @@
+import { Request, Response } from "express";
+import prisma from "../../prisma/client";
+
+export const followUser = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { followingId } = req.body;
+
+  try {
+    if (userId === followingId) {
+      return res
+        .status(400)
+        .json({ success: false, message: "Cannot follow yourself" });
+    }
+
+    const existingFollow = await prisma.follow.findUnique({
+      where: { followerId_followingId: { followerId: userId, followingId } },
+    });
+
+    if (existingFollow) {
+      return res
+        .status(400)
+        .json({ success: false, message: "Already following this user" });
+    }
+
+    const follow = await prisma.follow.create({
+      data: { followerId: userId, followingId },
+    });
+
+    await prisma.notification.create({
+      data: {
+        userId: followingId,
+        type: "FOLLOW",
+        title: "New Follower",
+        message: "Someone started following you",
+        link: `/profile/${userId}`,
+      },
+    });
+
+    res.json({ success: true, data: follow });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const unfollowUser = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { followingId } = req.params;
+
+  try {
+    await prisma.follow.delete({
+      where: { followerId_followingId: { followerId: userId, followingId } },
+    });
+
+    res.json({ success: true, message: "Unfollowed successfully" });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getFollowers = async (req: Request, res: Response) => {
+  const { userId } = req.params;
+
+  try {
+    const followers = await prisma.follow.findMany({
+      where: { followingId: userId },
+      include: {
+        follower: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            avatarUrl: true,
+            xp: true,
+          },
+        },
+      },
+    });
+
+    res.json({ success: true, data: followers });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getFollowing = async (req: Request, res: Response) => {
+  const { userId } = req.params;
+
+  try {
+    const following = await prisma.follow.findMany({
+      where: { followerId: userId },
+      include: {
+        following: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            avatarUrl: true,
+            xp: true,
+          },
+        },
+      },
+    });
+
+    res.json({ success: true, data: following });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const getActivityFeed = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { page = 1, limit = 20 } = req.query;
+
+  try {
+    const following = await prisma.follow.findMany({
+      where: { followerId: userId },
+      select: { followingId: true },
+    });
+
+    const followingIds = following.map((f) => f.followingId);
+
+    const activities = await prisma.userProject.findMany({
+      where: {
+        userId: { in: followingIds },
+        status: "COMPLETED",
+      },
+      include: {
+        user: {
+          select: {
+            id: true,
+            firstName: true,
+            lastName: true,
+            avatarUrl: true,
+          },
+        },
+        project: {
+          select: {
+            id: true,
+            title: true,
+            slug: true,
+          },
+        },
+      },
+      orderBy: { completedAt: "desc" },
+      take: Number(limit),
+      skip: (Number(page) - 1) * Number(limit),
+    });
+
+    res.json({ success: true, data: activities });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};
+
+export const shareProject = async (req: Request, res: Response) => {
+  const userId = (req as any).user?.id;
+  const { projectId, platform } = req.body;
+
+  try {
+    const project = await prisma.project.findUnique({
+      where: { id: projectId },
+    });
+
+    if (!project) {
+      return res
+        .status(404)
+        .json({ success: false, message: "Project not found" });
+    }
+
+    const shareUrl = `${process.env.CLIENT_URL}/projects/${project.slug}`;
+    const ogImageUrl = `${process.env.CLIENT_URL}/api/og-image/${project.slug}`;
+
+    const share = await prisma.socialShare.create({
+      data: {
+        userId,
+        projectId,
+        platform,
+        shareUrl,
+        ogImageUrl,
+      },
+    });
+
+    res.json({ success: true, data: { shareUrl, ogImageUrl, share } });
+  } catch (error: any) {
+    res.status(500).json({ success: false, message: error.message });
+  }
+};

controllers/teams/index.ts

@@ -0,0 +1,80 @@
+import { Request, Response, NextFunction } from "express";
+import prisma from "../../prisma/client";
+
+export const createTeam = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  const { name, projectId } = req.body;
+  const userId = (req as any).user?.id;
+
+  try {
+    const team = await prisma.team.create({
+      data: {
+        name,
+        projectId,
+        members: {
+          create: {
+            userId,
+          },
+        },
+      },
+      include: {
+        members: true,
+      },
+    });
+
+    res.status(201).json({ success: true, data: team });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const joinTeam = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  const { id: teamId } = req.params;
+  const userId = (req as any).user?.id;
+
+  try {
+    const teamMember = await prisma.teamMember.create({
+      data: {
+        teamId,
+        userId,
+      },
+    });
+
+    res.status(201).json({ success: true, data: teamMember });
+  } catch (error: any) {
+    next(error);
+  }
+};
+
+export const getTeamProjects = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  const { id: teamId } = req.params;
+
+  try {
+    const team = await prisma.team.findUnique({
+      where: { id: teamId },
+      include: {
+        project: true,
+      },
+    });
+
+    if (!team)
+      return res
+        .status(404)
+        .json({ success: false, message: "Team not found" });
+
+    res.json({ success: true, data: team.project });
+  } catch (error: any) {
+    next(error);
+  }
+};

dist/controllers/ai/index.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestHint = exports.getChatHistory = exports.getAllChatMessages = exports.chatWithAI = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const gemini_1 = require("../../utils/gemini");
+const chatWithAI = async (req, res) => {
+    var _a, _b, _c;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { message, projectId } = req.body;
+    try {
+        // Fetch project context if projectId is provided
+        let projectContext = "";
+        let difficultyMode = null;
+        if (projectId) {
+            const project = await client_1.default.project.findUnique({
+                where: { id: projectId },
+                include: {
+                    milestones: true,
+                    userProjects: { where: { userId } },
+                },
+            });
+            if (project) {
+                difficultyMode =
+                    ((_c = (_b = project.userProjects) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.difficultyModeChosen) || "STANDARD";
+                projectContext = `The user is working on the project: "${project.title}". 
+        Description: ${project.description}.
+        Difficulty Level: ${project.difficultyLevel}.
+        User's chosen mode: ${difficultyMode}.
+        Milestones: ${project.milestones
+                    .map((m) => `${m.milestoneNumber}. ${m.title}`)
+                    .join(", ")}.`;
+            }
+        }
+        // Fetch chat history from DB
+        const history = await client_1.default.chatMessage.findMany({
+            where: { userId, projectId: projectId || null },
+            orderBy: { createdAt: "asc" },
+            take: 20,
+        });
+        const geminiHistory = history.map((msg) => ({
+            role: msg.role === "user" ? "user" : "model",
+            parts: [{ text: msg.content }],
+        }));
+        let modeInstruction = "";
+        if (difficultyMode === "GUIDED") {
+            modeInstruction =
+                "The user is in GUIDED mode. Be very helpful, provide detailed explanations, and don't hesitate to give small code snippets if they are stuck.";
+        }
+        else if (difficultyMode === "HARDCORE") {
+            modeInstruction =
+                "The user is in HARDCORE mode. Be very brief, provide only high-level conceptual hints, and never provide code solutions.";
+        }
+        else {
+            modeInstruction =
+                "The user is in STANDARD mode. Provide balanced guidance, focus on concepts, and only provide code as a last resort.";
+        }
+        const systemPrompt = `You are an AI Guide for a project-based learning platform. 
+    Your goal is to help students learn by providing guidance, not just giving away answers.
+    ${projectContext}
+    ${modeInstruction}
+    Keep your responses concise and educational.`;
+        const fullPrompt = `${systemPrompt}\n\nUser: ${message}`;
+        const aiResponse = await (0, gemini_1.getGeminiResponse)(fullPrompt, geminiHistory);
+        // Save messages to DB
+        await client_1.default.chatMessage.createMany({
+            data: [
+                {
+                    userId,
+                    projectId: projectId || null,
+                    role: "user",
+                    content: message,
+                },
+                {
+                    userId,
+                    projectId: projectId || null,
+                    role: "assistant",
+                    content: aiResponse,
+                },
+            ],
+        });
+        res.json({ success: true, data: aiResponse });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.chatWithAI = chatWithAI;
+const getAllChatMessages = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const messages = await client_1.default.chatMessage.findMany({
+            where: { userId },
+            orderBy: { createdAt: "asc" },
+        });
+        res.json({ success: true, data: messages });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getAllChatMessages = getAllChatMessages;
+const getChatHistory = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { projectId } = req.params;
+    try {
+        const history = await client_1.default.chatMessage.findMany({
+            where: { userId, projectId: projectId === "null" ? null : projectId },
+            orderBy: { createdAt: "asc" },
+        });
+        res.json({ success: true, data: history });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getChatHistory = getChatHistory;
+const requestHint = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { projectId, milestoneNumber } = req.body;
+    try {
+        const milestone = await client_1.default.projectMilestone.findUnique({
+            where: { projectId_milestoneNumber: { projectId, milestoneNumber } },
+            include: { project: true },
+        });
+        if (!milestone)
+            return res
+                .status(404)
+                .json({ success: false, message: "Milestone not found" });
+        const prompt = `The user is stuck on Milestone ${milestoneNumber} ("${milestone.title}") of the project "${milestone.project.title}".
+    Milestone description: ${milestone.description}.
+    Existing hints: ${milestone.hints.join(", ")}.
+    Please provide a new, progressive hint that helps them move forward without revealing the full solution.`;
+        const hint = await (0, gemini_1.getGeminiResponse)(prompt);
+        res.json({ success: true, data: hint });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.requestHint = requestHint;

dist/controllers/analytics/index.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAdminAnalytics = exports.getUserAnalytics = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const getUserAnalytics = async (req, res, next) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const user = await client_1.default.user.findUnique({
+            where: { id: userId },
+            select: {
+                xp: true,
+                streak: true,
+                _count: {
+                    select: {
+                        projects: true,
+                        submissions: true,
+                        achievements: true
+                    }
+                }
+            }
+        });
+        const projectCompletion = await client_1.default.userProject.groupBy({
+            by: ["status"],
+            where: { userId },
+            _count: true
+        });
+        res.json({
+            success: true,
+            data: {
+                stats: user,
+                projectCompletion
+            }
+        });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.getUserAnalytics = getUserAnalytics;
+const getAdminAnalytics = async (req, res, next) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const user = await client_1.default.user.findUnique({ where: { id: userId } });
+        if ((user === null || user === void 0 ? void 0 : user.role) !== "ADMIN") {
+            return res.status(403).json({ success: false, message: "Forbidden" });
+        }
+        const totalUsers = await client_1.default.user.count();
+        const totalProjects = await client_1.default.project.count();
+        const totalSubmissions = await client_1.default.submission.count();
+        const popularProjects = await client_1.default.project.findMany({
+            orderBy: { submissionCount: "desc" },
+            take: 5,
+            select: { title: true, submissionCount: true }
+        });
+        res.json({
+            success: true,
+            data: {
+                totalUsers,
+                totalProjects,
+                totalSubmissions,
+                popularProjects
+            }
+        });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.getAdminAnalytics = getAdminAnalytics;

dist/controllers/auth/index.js

@@ -0,0 +1,397 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubAuthCallback = exports.googleAuthCallback = exports.updateUser = exports.getUser = exports.resetPassword = exports.verifyOTP = exports.forgetPassword = exports.me = exports.logout = exports.login = exports.signUp = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const argon2 = __importStar(require("argon2"));
+const email_1 = require("../../middlewares/email");
+const generateOTP_1 = require("../../middlewares/generateOTP");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const redis_1 = __importDefault(require("../../utils/redis"));
+dotenv_1.default.config();
+const JWT_SECRET = process.env.JWT_SECRET || "default_secret";
+const signUp = async (req, res) => {
+    const { firstName, lastName, skillLevel, email, password, role } = req.body;
+    try {
+        const existingUser = await client_1.default.user.findUnique({ where: { email } });
+        if (existingUser) {
+            return res
+                .status(400)
+                .json({ success: false, message: "Email already registered" });
+        }
+        const hashedPassword = await argon2.hash(password);
+        const user = await client_1.default.user.create({
+            data: {
+                firstName,
+                lastName,
+                email,
+                skillLevel: skillLevel || "BEGINNER",
+                password: hashedPassword,
+                role: role || "STUDENT",
+            },
+        });
+        res.json({
+            success: true,
+            message: "User registered successfully",
+            data: { id: user.id },
+        });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.signUp = signUp;
+const login = async (req, res) => {
+    const { email, password } = req.body;
+    try {
+        const user = await client_1.default.user.findUnique({ where: { email } });
+        if (!user || !user.password) {
+            return res
+                .status(401)
+                .json({ success: false, message: "Invalid Email or Password" });
+        }
+        const verifyPassword = await argon2.verify(user.password, password);
+        if (!verifyPassword) {
+            return res
+                .status(401)
+                .json({ success: false, message: "Invalid Email or Password" });
+        }
+        const token = jsonwebtoken_1.default.sign({ id: user.id, role: user.role }, JWT_SECRET, {
+            expiresIn: "7d",
+        });
+        res.cookie("token", token, {
+            httpOnly: true,
+            secure: process.env.NODE_ENV === "production",
+            sameSite: "strict",
+            maxAge: 7 * 24 * 60 * 60 * 1000, // 7 days
+        });
+        res.json({
+            success: true,
+            message: "Login successful",
+            data: {
+                id: user.id,
+                firstName: user.firstName,
+                lastName: user.lastName,
+                email: user.email,
+                role: user.role,
+                token,
+            },
+        });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.login = login;
+const logout = async (req, res) => {
+    res.clearCookie("token");
+    res.json({ success: true, message: "Logged out successfully" });
+};
+exports.logout = logout;
+const me = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    if (!userId) {
+        return res.status(401).json({ success: false, message: "Unauthorized" });
+    }
+    try {
+        const user = await client_1.default.user.findUnique({
+            where: { id: userId },
+            select: {
+                id: true,
+                email: true,
+                firstName: true,
+                lastName: true,
+                skillLevel: true,
+                bio: true,
+                portfolioLinks: true,
+                xp: true,
+                streak: true,
+                role: true,
+                avatarUrl: true,
+                createdAt: true,
+            },
+        });
+        if (!user) {
+            return res
+                .status(404)
+                .json({ success: false, message: "User not found" });
+        }
+        res.json({ success: true, data: user });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.me = me;
+const forgetPassword = async (req, res) => {
+    const { email } = req.body;
+    const appName = "Dev Drill";
+    try {
+        const user = await client_1.default.user.findUnique({ where: { email } });
+        if (!user) {
+            return res
+                .status(404)
+                .json({ success: false, message: "Account is not registered" });
+        }
+        const { otp, otpDate } = (0, generateOTP_1.generateOTP)();
+        // Store OTP in Redis with 1 hour expiry
+        await redis_1.default.setex(`otp:${email}`, 3600, otp.toString());
+        const htmlMessage = `
+      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+        <div style="background: #f0f7ff; padding: 30px; border-radius: 10px;">
+          <h1 style="color: #1a237e; margin-bottom: 25px;">${appName}</h1>
+          <p style="font-size: 16px; color: #333;">
+            Hello ${user.lastName},<br><br>
+            We received a request to reset your password for your ${appName} account.
+          </p>
+          <div style="background: #fff; padding: 20px; border-radius: 5px; margin: 20px 0; text-align: center;">
+            <p style="margin: 0; font-weight: bold; font-size: 24px; letter-spacing: 2px;">${otp}</p>
+          </div>
+          <p style="font-size: 14px; color: #666;">
+            This verification code will expire in 1 hour.<br>
+            If you didn't request this password reset, please ignore this email.
+          </p>
+        </div>
+        <p style="font-size: 12px; color: #999; text-align: center; margin-top: 20px;">
+          © ${new Date().getFullYear()} ${appName}. All rights reserved.
+        </p>
+      </div>
+    `;
+        const textMessage = `${appName} Password Reset\n\n` +
+            `Hello ${user.lastName},\n\n` +
+            `Use this OTP to reset your password: ${otp}\n` +
+            `This code expires in 1 hour.`;
+        (0, email_1.sendEmail)(user.email, `Password Reset Request - ${appName}`, htmlMessage, textMessage);
+        res.json({
+            success: true,
+            message: `An OTP has been sent to your mail. Check your mail for your verification code`,
+        });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.forgetPassword = forgetPassword;
+const verifyOTP = async (req, res) => {
+    const { email, otp: userOtp } = req.body;
+    try {
+        const storedOtp = await redis_1.default.get(`otp:${email}`);
+        if (!storedOtp) {
+            return res
+                .status(400)
+                .json({ success: false, message: "OTP expired or not found" });
+        }
+        if (storedOtp !== userOtp.toString()) {
+            return res
+                .status(400)
+                .json({ success: false, message: "Invalid Verification code!" });
+        }
+        // OTP verified, can remove it now
+        await redis_1.default.del(`otp:${email}`);
+        // Optionally set a flag in Redis that OTP was verified for this email to allow password reset
+        await redis_1.default.setex(`otp_verified:${email}`, 600, "true");
+        res.json({ success: true, message: "Verification successful" });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.verifyOTP = verifyOTP;
+const resetPassword = async (req, res) => {
+    const { email, newPassword } = req.body;
+    try {
+        const isVerified = await redis_1.default.get(`otp_verified:${email}`);
+        if (!isVerified) {
+            return res
+                .status(400)
+                .json({ success: false, message: "OTP not verified" });
+        }
+        const user = await client_1.default.user.findUnique({ where: { email } });
+        if (!user)
+            return res
+                .status(404)
+                .json({ success: false, message: "User not found" });
+        if (user.password) {
+            const verifyPassword = await argon2.verify(user.password, newPassword);
+            if (verifyPassword) {
+                return res
+                    .status(400)
+                    .json({ success: false, message: "You entered your old password" });
+            }
+        }
+        const newPass = await argon2.hash(newPassword);
+        await client_1.default.user.update({
+            where: { email },
+            data: { password: newPass },
+        });
+        await redis_1.default.del(`otp_verified:${email}`);
+        res.json({ success: true, message: "Password successfully reset" });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.resetPassword = resetPassword;
+const getUser = async (req, res) => {
+    const { id } = req.params;
+    try {
+        const user = await client_1.default.user.findUnique({
+            where: { id },
+            select: {
+                id: true,
+                email: true,
+                firstName: true,
+                lastName: true,
+                skillLevel: true,
+                bio: true,
+                portfolioLinks: true,
+                xp: true,
+                streak: true,
+                role: true,
+                avatarUrl: true,
+                createdAt: true,
+            },
+        });
+        if (!user)
+            return res
+                .status(404)
+                .json({ success: false, message: "User not found" });
+        res.json({ success: true, data: user });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getUser = getUser;
+const updateUser = async (req, res) => {
+    const { id } = req.params;
+    let { firstName, lastName, email, password, bio, skillLevel, portfolioLinks, avatarUrl, } = req.body;
+    try {
+        const user = await client_1.default.user.findUnique({ where: { id } });
+        if (!user) {
+            return res
+                .status(404)
+                .json({ success: false, message: "User not found" });
+        }
+        const data = {
+            firstName,
+            lastName,
+            bio,
+            skillLevel,
+            portfolioLinks,
+            avatarUrl,
+        };
+        if (email && email !== user.email) {
+            const existingUser = await client_1.default.user.findUnique({ where: { email } });
+            if (existingUser) {
+                return res
+                    .status(400)
+                    .json({ success: false, message: "Email already in use" });
+            }
+            data.email = email;
+        }
+        if (password) {
+            data.password = await argon2.hash(password);
+        }
+        const updatedUser = await client_1.default.user.update({
+            where: { googleId: user.googleId || undefined },
+            data,
+        });
+        res.json({
+            success: true,
+            data: {
+                id: updatedUser.id,
+                firstName: updatedUser.firstName,
+                lastName: updatedUser.lastName,
+                email: updatedUser.email,
+                role: updatedUser.role,
+                skillLevel: updatedUser.skillLevel,
+            },
+        });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.updateUser = updateUser;
+const googleAuthCallback = async (req, res) => {
+    try {
+        const user = req.user;
+        if (!user) {
+            return res.redirect(`${process.env.CLIENT_URL}/auth/signin?error=auth_failed`);
+        }
+        const token = jsonwebtoken_1.default.sign({ id: user.id, role: user.role }, JWT_SECRET, {
+            expiresIn: "7d",
+        });
+        res.cookie("token", token, {
+            httpOnly: true,
+            secure: process.env.NODE_ENV === "production",
+            sameSite: "lax",
+            maxAge: 7 * 24 * 60 * 60 * 1000,
+        });
+        res.redirect(`${process.env.CLIENT_URL}/dashboard`);
+    }
+    catch (error) {
+        res.redirect(`${process.env.CLIENT_URL}/auth/signin?error=server_error`);
+    }
+};
+exports.googleAuthCallback = googleAuthCallback;
+const githubAuthCallback = async (req, res) => {
+    try {
+        const user = req.user;
+        if (!user) {
+            return res.redirect(`${process.env.CLIENT_URL}/auth/signin?error=auth_failed`);
+        }
+        const token = jsonwebtoken_1.default.sign({ id: user.id, role: user.role }, JWT_SECRET, {
+            expiresIn: "7d",
+        });
+        res.cookie("token", token, {
+            httpOnly: true,
+            secure: process.env.NODE_ENV === "production",
+            sameSite: "lax",
+            maxAge: 7 * 24 * 60 * 60 * 1000,
+        });
+        res.redirect(`${process.env.CLIENT_URL}/dashboard`);
+    }
+    catch (error) {
+        res.redirect(`${process.env.CLIENT_URL}/auth/signin?error=server_error`);
+    }
+};
+exports.githubAuthCallback = githubAuthCallback;

dist/controllers/code-review/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubmissionReview = exports.analyzeCode = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const gemini_1 = require("../../utils/gemini");
+const axios_1 = __importDefault(require("axios"));
+const analyzeCode = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { repoUrl, projectId } = req.body;
+    try {
+        // 1. Fetch code from GitHub (simplified: fetch README or a few files for demo)
+        // In a real app, you'd use a GitHub App or User Token to clone or fetch via API
+        const repoPath = repoUrl.replace("https://github.com/", "");
+        const [owner, repo] = repoPath.split("/");
+        // Fetch repo info as a placeholder for analysis
+        const githubApiUrl = `https://api.github.com/repos/${owner}/${repo}`;
+        const repoInfo = await axios_1.default.get(githubApiUrl);
+        // 2. Automated analysis (simulated)
+        const metrics = {
+            complexity: "Medium",
+            securityIssues: 0,
+            lintErrors: 0
+        };
+        // 3. AI-powered feedback
+        const prompt = `Please review this GitHub repository: ${repoUrl}.
+    Owner: ${owner}
+    Repo: ${repo}
+    Description: ${repoInfo.data.description}
+    Provide constructive feedback on the project structure and suggest improvements for a student.`;
+        const feedback = await (0, gemini_1.getGeminiResponse)(prompt);
+        // 4. Store review results
+        const submission = await client_1.default.submission.create({
+            data: {
+                userId,
+                projectId,
+                repoUrl,
+                feedback,
+                score: 85 // Simulated score
+            }
+        });
+        res.json({ success: true, data: submission });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.analyzeCode = analyzeCode;
+const getSubmissionReview = async (req, res) => {
+    const { id } = req.params;
+    try {
+        const submission = await client_1.default.submission.findUnique({
+            where: { id },
+            include: {
+                project: { select: { title: true } },
+                user: { select: { firstName: true, lastName: true } }
+            }
+        });
+        if (!submission)
+            return res.status(404).json({ success: false, message: "Submission not found" });
+        res.json({ success: true, data: submission });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getSubmissionReview = getSubmissionReview;

dist/controllers/community/index.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createForumThread = exports.getForumThreads = exports.voteOnSubmission = exports.commentOnSubmission = exports.getPublicSubmissions = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const getPublicSubmissions = async (req, res, next) => {
+    try {
+        const submissions = await client_1.default.submission.findMany({
+            where: { isPublic: true },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        firstName: true,
+                        lastName: true,
+                        avatarUrl: true,
+                    },
+                },
+                project: {
+                    select: {
+                        id: true,
+                        title: true,
+                    },
+                },
+                _count: {
+                    select: {
+                        comments: true,
+                        votes: true,
+                    },
+                },
+            },
+            orderBy: { createdAt: "desc" },
+        });
+        res.json({ success: true, data: submissions });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.getPublicSubmissions = getPublicSubmissions;
+const commentOnSubmission = async (req, res, next) => {
+    var _a;
+    const { id: submissionId } = req.params;
+    const { content } = req.body;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const comment = await client_1.default.comment.create({
+            data: {
+                content,
+                userId,
+                submissionId,
+            },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        firstName: true,
+                        lastName: true,
+                        avatarUrl: true,
+                    },
+                },
+            },
+        });
+        res.status(201).json({ success: true, data: comment });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.commentOnSubmission = commentOnSubmission;
+const voteOnSubmission = async (req, res, next) => {
+    var _a;
+    const { id: submissionId } = req.params;
+    const { value } = req.body; // 1 for upvote, -1 for downvote
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const vote = await client_1.default.vote.upsert({
+            where: {
+                userId_submissionId: {
+                    userId,
+                    submissionId,
+                },
+            },
+            update: { value },
+            create: {
+                value,
+                userId,
+                submissionId,
+            },
+        });
+        res.json({ success: true, data: vote });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.voteOnSubmission = voteOnSubmission;
+const getForumThreads = async (req, res, next) => {
+    const { projectId } = req.query;
+    try {
+        const threads = await client_1.default.forumThread.findMany({
+            where: projectId ? { projectId: String(projectId) } : {},
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        firstName: true,
+                        lastName: true,
+                        avatarUrl: true,
+                    },
+                },
+                _count: {
+                    select: { posts: true },
+                },
+            },
+            orderBy: { createdAt: "desc" },
+        });
+        res.json({ success: true, data: threads });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.getForumThreads = getForumThreads;
+const createForumThread = async (req, res, next) => {
+    var _a;
+    const { title, content, projectId } = req.body;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const thread = await client_1.default.forumThread.create({
+            data: {
+                title,
+                content,
+                userId,
+                projectId: projectId || null,
+            },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        firstName: true,
+                        lastName: true,
+                        avatarUrl: true,
+                    },
+                },
+            },
+        });
+        res.status(201).json({ success: true, data: thread });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.createForumThread = createForumThread;

dist/controllers/events/index.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLeaderboard = exports.updateEventScore = exports.leaveEvent = exports.joinEvent = exports.getEvent = exports.getEvents = exports.createEvent = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const createEvent = async (req, res) => {
+    const { title, description, type, startDate, endDate, prizePool, maxParticipants, bannerUrl, } = req.body;
+    try {
+        const event = await client_1.default.event.create({
+            data: {
+                title,
+                description,
+                type,
+                startDate: new Date(startDate),
+                endDate: new Date(endDate),
+                prizePool,
+                maxParticipants,
+                bannerUrl,
+            },
+        });
+        res.json({ success: true, data: event });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.createEvent = createEvent;
+const getEvents = async (req, res) => {
+    const { status, type, page = 1, limit = 10 } = req.query;
+    try {
+        const where = {};
+        if (status)
+            where.status = status;
+        if (type)
+            where.type = type;
+        const events = await client_1.default.event.findMany({
+            where,
+            include: {
+                _count: {
+                    select: { participants: true },
+                },
+            },
+            orderBy: { startDate: "desc" },
+            take: Number(limit),
+            skip: (Number(page) - 1) * Number(limit),
+        });
+        res.json({ success: true, data: events });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getEvents = getEvents;
+const getEvent = async (req, res) => {
+    const { id } = req.params;
+    try {
+        const event = await client_1.default.event.findUnique({
+            where: { id },
+            include: {
+                participants: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                firstName: true,
+                                lastName: true,
+                                avatarUrl: true,
+                            },
+                        },
+                    },
+                },
+                leaderboard: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                firstName: true,
+                                lastName: true,
+                                avatarUrl: true,
+                            },
+                        },
+                    },
+                    orderBy: { score: "desc" },
+                    take: 100,
+                },
+            },
+        });
+        if (!event) {
+            return res
+                .status(404)
+                .json({ success: false, message: "Event not found" });
+        }
+        res.json({ success: true, data: event });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getEvent = getEvent;
+const joinEvent = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { eventId } = req.params;
+    try {
+        const event = await client_1.default.event.findUnique({
+            where: { id: eventId },
+            include: { _count: { select: { participants: true } } },
+        });
+        if (!event) {
+            return res
+                .status(404)
+                .json({ success: false, message: "Event not found" });
+        }
+        if (event.maxParticipants &&
+            event._count.participants >= event.maxParticipants) {
+            return res.status(400).json({ success: false, message: "Event is full" });
+        }
+        const participant = await client_1.default.eventParticipant.create({
+            data: { eventId, userId },
+        });
+        await client_1.default.eventLeaderboard.create({
+            data: { eventId, userId, score: 0 },
+        });
+        res.json({ success: true, data: participant });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.joinEvent = joinEvent;
+const leaveEvent = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { eventId } = req.params;
+    try {
+        await client_1.default.eventParticipant.delete({
+            where: { eventId_userId: { eventId, userId } },
+        });
+        await client_1.default.eventLeaderboard.delete({
+            where: { eventId_userId: { eventId, userId } },
+        });
+        res.json({ success: true, message: "Left event successfully" });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.leaveEvent = leaveEvent;
+const updateEventScore = async (req, res) => {
+    const { eventId, userId } = req.params;
+    const { score } = req.body;
+    try {
+        const leaderboard = await client_1.default.eventLeaderboard.update({
+            where: { eventId_userId: { eventId, userId } },
+            data: { score },
+        });
+        const allScores = await client_1.default.eventLeaderboard.findMany({
+            where: { eventId },
+            orderBy: { score: "desc" },
+        });
+        for (let i = 0; i < allScores.length; i++) {
+            await client_1.default.eventLeaderboard.update({
+                where: { id: allScores[i].id },
+                data: { rank: i + 1 },
+            });
+        }
+        res.json({ success: true, data: leaderboard });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.updateEventScore = updateEventScore;
+const getLeaderboard = async (req, res) => {
+    const { eventId } = req.params;
+    const { limit = 100 } = req.query;
+    try {
+        const leaderboard = await client_1.default.eventLeaderboard.findMany({
+            where: { eventId },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        firstName: true,
+                        lastName: true,
+                        avatarUrl: true,
+                        xp: true,
+                    },
+                },
+            },
+            orderBy: { score: "desc" },
+            take: Number(limit),
+        });
+        res.json({ success: true, data: leaderboard });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getLeaderboard = getLeaderboard;

dist/controllers/gamification/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awardXP = exports.getUserAchievements = exports.getLeaderboard = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const redis_1 = __importDefault(require("../../utils/redis"));
+const LEADERBOARD_CACHE_KEY = "leaderboard:top20";
+const CACHE_TTL = 3600; // 1 hour
+const getLeaderboard = async (req, res, next) => {
+    try {
+        // Try to get from cache
+        const cachedLeaderboard = await redis_1.default.get(LEADERBOARD_CACHE_KEY);
+        if (cachedLeaderboard) {
+            return res.json({ success: true, data: JSON.parse(cachedLeaderboard), cached: true });
+        }
+        const leaderboard = await client_1.default.user.findMany({
+            select: {
+                id: true,
+                firstName: true,
+                lastName: true,
+                avatarUrl: true,
+                xp: true,
+                streak: true
+            },
+            orderBy: { xp: "desc" },
+            take: 20
+        });
+        // Save to cache
+        await redis_1.default.setex(LEADERBOARD_CACHE_KEY, CACHE_TTL, JSON.stringify(leaderboard));
+        res.json({ success: true, data: leaderboard });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.getLeaderboard = getLeaderboard;
+const getUserAchievements = async (req, res, next) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const achievements = await client_1.default.userAchievement.findMany({
+            where: { userId },
+            include: {
+                achievement: true
+            }
+        });
+        res.json({ success: true, data: achievements });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.getUserAchievements = getUserAchievements;
+const awardXP = async (userId, amount) => {
+    try {
+        await client_1.default.user.update({
+            where: { id: userId },
+            data: {
+                xp: { increment: amount }
+            }
+        });
+        // Invalidate leaderboard cache when XP changes
+        await redis_1.default.del(LEADERBOARD_CACHE_KEY);
+    }
+    catch (error) {
+        console.error("Error awarding XP:", error);
+    }
+};
+exports.awardXP = awardXP;

dist/controllers/notifications/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteNotification = exports.markAllAsRead = exports.markAsRead = exports.getNotifications = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const getNotifications = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { page = 1, limit = 20, unreadOnly = false } = req.query;
+    try {
+        const where = { userId };
+        if (unreadOnly === "true") {
+            where.read = false;
+        }
+        const notifications = await client_1.default.notification.findMany({
+            where,
+            orderBy: { createdAt: "desc" },
+            take: Number(limit),
+            skip: (Number(page) - 1) * Number(limit),
+        });
+        const unreadCount = await client_1.default.notification.count({
+            where: { userId, read: false },
+        });
+        res.json({ success: true, data: { notifications, unreadCount } });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getNotifications = getNotifications;
+const markAsRead = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { notificationId } = req.params;
+    try {
+        await client_1.default.notification.updateMany({
+            where: { id: notificationId, userId },
+            data: { read: true },
+        });
+        res.json({ success: true, message: "Notification marked as read" });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.markAsRead = markAsRead;
+const markAllAsRead = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        await client_1.default.notification.updateMany({
+            where: { userId, read: false },
+            data: { read: true },
+        });
+        res.json({ success: true, message: "All notifications marked as read" });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.markAllAsRead = markAllAsRead;
+const deleteNotification = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { notificationId } = req.params;
+    try {
+        await client_1.default.notification.deleteMany({
+            where: { id: notificationId, userId },
+        });
+        res.json({ success: true, message: "Notification deleted" });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.deleteNotification = deleteNotification;

dist/controllers/paths/index.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startPath = exports.getPathProgress = exports.getLearningPaths = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const getLearningPaths = async (req, res, next) => {
+    try {
+        const paths = await client_1.default.learningPath.findMany({
+            include: {
+                projects: {
+                    include: {
+                        project: {
+                            select: {
+                                title: true,
+                                difficultyLevel: true,
+                            },
+                        },
+                    },
+                    orderBy: { orderIndex: "asc" },
+                },
+            },
+        });
+        res.json({ success: true, data: paths });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.getLearningPaths = getLearningPaths;
+const getPathProgress = async (req, res, next) => {
+    var _a;
+    const { id: pathId } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const progress = await client_1.default.userPathProgress.findUnique({
+            where: {
+                userId_pathId: {
+                    userId,
+                    pathId,
+                },
+            },
+            include: {
+                path: {
+                    include: {
+                        projects: {
+                            include: { project: true },
+                            orderBy: { orderIndex: "asc" },
+                        },
+                    },
+                },
+            },
+        });
+        res.json({ success: true, data: progress });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.getPathProgress = getPathProgress;
+const startPath = async (req, res, next) => {
+    var _a;
+    const { id: pathId } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const progress = await client_1.default.userPathProgress.upsert({
+            where: {
+                userId_pathId: {
+                    userId,
+                    pathId
+                }
+            },
+            update: {},
+            create: {
+                userId,
+                pathId,
+                currentProjectIndex: 0,
+            },
+        });
+        res.status(201).json({ success: true, data: progress });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.startPath = startPath;

dist/controllers/projects/index.js

@@ -0,0 +1,416 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFeaturedProjects = exports.completeMilestone = exports.submitProject = exports.getUserProgress = exports.completeProject = exports.updateProgress = exports.startProject = exports.getProjectById = exports.getProjects = exports.deleteProject = exports.updateProject = exports.createProject = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const file_1 = require("../../middlewares/file");
+const auth_1 = require("../../middlewares/auth");
+function generateSlug(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+const createProject = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { title, description, difficultyLevel, technologies, categories, estimatedTime, learningObjectives, resourceLinks, starterRepoUrl, difficultyModes, coverImage, milestones, } = req.body;
+    try {
+        if (!userId)
+            return res.status(401).json({ success: false, message: "Unauthorized" });
+        const user = await client_1.default.user.findUnique({ where: { id: userId } });
+        if (!user || (user.role !== "ADMIN" && user.role !== "CONTRIBUTOR")) {
+            return res.status(403).json({
+                success: false,
+                message: "Only Admins or Contributors can create projects",
+            });
+        }
+        let imageUrl = coverImage;
+        if (coverImage && !coverImage.startsWith("http")) {
+            imageUrl = await (0, file_1.upLoadFiles)(coverImage);
+        }
+        const project = await client_1.default.project.create({
+            data: {
+                title,
+                slug: generateSlug(title),
+                description,
+                difficultyLevel: difficultyLevel,
+                technologies,
+                categories,
+                estimatedTime,
+                learningObjectives,
+                resourceLinks: resourceLinks || [],
+                starterRepoUrl,
+                difficultyModes: difficultyModes || ["GUIDED", "STANDARD", "HARDCORE"],
+                createdBy: { connect: { id: userId } },
+                milestones: {
+                    create: milestones === null || milestones === void 0 ? void 0 : milestones.map((m, index) => ({
+                        milestoneNumber: index + 1,
+                        title: m.title,
+                        description: m.description,
+                        hints: m.hints || [],
+                        validationCriteria: m.validationCriteria,
+                    })),
+                },
+            },
+            include: {
+                milestones: true,
+            },
+        });
+        res.status(201).json({ success: true, data: project });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.createProject = createProject;
+const updateProject = async (req, res) => {
+    var _a;
+    const { id } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const updateData = req.body;
+    try {
+        const project = await client_1.default.project.findUnique({ where: { id } });
+        if (!project)
+            return res
+                .status(404)
+                .json({ success: false, message: "Project not found" });
+        // Check permissions
+        const user = await client_1.default.user.findUnique({ where: { id: userId } });
+        if (!user || (user.role !== "ADMIN" && project.createdById !== userId)) {
+            return res.status(403).json({
+                success: false,
+                message: "Unauthorized to update this project",
+            });
+        }
+        const updatedProject = await client_1.default.project.update({
+            where: { id },
+            data: updateData,
+            include: { milestones: true },
+        });
+        res.json({ success: true, data: updatedProject });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.updateProject = updateProject;
+const deleteProject = async (req, res) => {
+    var _a;
+    const { id } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const project = await client_1.default.project.findUnique({ where: { id } });
+        if (!project)
+            return res
+                .status(404)
+                .json({ success: false, message: "Project not found" });
+        const user = await client_1.default.user.findUnique({ where: { id: userId } });
+        if (!user || user.role !== "ADMIN") {
+            return res
+                .status(403)
+                .json({ success: false, message: "Only Admins can delete projects" });
+        }
+        await client_1.default.project.delete({ where: { id } });
+        res.json({ success: true, message: "Project deleted successfully" });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.deleteProject = deleteProject;
+const getProjects = async (req, res) => {
+    const { difficulty, tech, category, title } = req.query;
+    try {
+        const where = {};
+        if (difficulty)
+            where.difficultyLevel = difficulty;
+        if (tech)
+            where.technologies = { has: tech };
+        if (category)
+            where.categories = { has: category };
+        if (title)
+            where.title = { contains: title, mode: "insensitive" };
+        const projects = await client_1.default.project.findMany({
+            where,
+            include: {
+                createdBy: {
+                    select: { firstName: true, lastName: true },
+                },
+            },
+            orderBy: { createdAt: "desc" },
+        });
+        res.json({ success: true, data: projects });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getProjects = getProjects;
+const getProjectById = async (req, res) => {
+    var _a;
+    const { id } = req.params;
+    try {
+        const user = await (0, auth_1.checkAuth)(req);
+        const project = (await client_1.default.project.findUnique({
+            where: { id },
+            include: {
+                milestones: { orderBy: { milestoneNumber: "asc" } },
+                createdBy: { select: { firstName: true, lastName: true } },
+                userProjects: user ? { where: { userId: user.id } } : false,
+            },
+        }));
+        if (!project)
+            return res
+                .status(404)
+                .json({ success: false, message: "Project not found" });
+        // If user is authenticated, fetch their progress and completed milestones for each mode
+        let progressByMode = {};
+        if (user && project.userProjects) {
+            for (const up of project.userProjects) {
+                const completedMilestones = await client_1.default.userMilestone.findMany({
+                    where: {
+                        userId: user.id,
+                        userProjectId: up.id,
+                    },
+                    select: { milestoneId: true },
+                });
+                progressByMode[up.difficultyModeChosen] = {
+                    status: up.status,
+                    completedMilestones: completedMilestones.map((m) => m.milestoneId),
+                    userProjectId: up.id,
+                };
+            }
+        }
+        res.json({
+            success: true,
+            data: {
+                ...project,
+                progressByMode,
+                // For backward compatibility
+                userProgress: ((_a = project.userProjects) === null || _a === void 0 ? void 0 : _a[0]) || null,
+            },
+        });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getProjectById = getProjectById;
+// User Progress Endpoints
+const startProject = async (req, res) => {
+    var _a;
+    const { id: projectId } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { difficultyModeChosen } = req.body;
+    try {
+        const mode = difficultyModeChosen || "STANDARD";
+        const existingProgress = await client_1.default.userProject.findUnique({
+            where: {
+                userId_projectId_difficultyModeChosen: {
+                    userId,
+                    projectId,
+                    difficultyModeChosen: mode,
+                },
+            },
+        });
+        if (existingProgress) {
+            return res.status(400).json({
+                success: false,
+                message: "Project already started in this mode",
+            });
+        }
+        const progress = await client_1.default.userProject.create({
+            data: {
+                userId,
+                projectId,
+                difficultyModeChosen: mode,
+                status: "IN_PROGRESS",
+            },
+        });
+        res.status(201).json({ success: true, data: progress });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.startProject = startProject;
+const updateProgress = async (req, res) => {
+    var _a;
+    const { id: projectId } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { status, repoUrl, difficultyMode } = req.body;
+    try {
+        const progress = await client_1.default.userProject.update({
+            where: {
+                userId_projectId_difficultyModeChosen: {
+                    userId,
+                    projectId,
+                    difficultyModeChosen: difficultyMode,
+                },
+            },
+            data: { status: status, repoUrl },
+        });
+        res.json({ success: true, data: progress });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.updateProgress = updateProgress;
+const completeProject = async (req, res) => {
+    var _a;
+    const { id: projectId } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { repoUrl, difficultyMode } = req.body;
+    try {
+        const progress = await client_1.default.userProject.update({
+            where: {
+                userId_projectId_difficultyModeChosen: {
+                    userId,
+                    projectId,
+                    difficultyModeChosen: difficultyMode,
+                },
+            },
+            data: {
+                status: "COMPLETED",
+                completedAt: new Date(),
+                repoUrl,
+            },
+        });
+        // Award XP (simple example)
+        await client_1.default.user.update({
+            where: { id: userId },
+            data: { xp: { increment: 100 } },
+        });
+        // Update project completion rate
+        const totalStarted = await client_1.default.userProject.count({
+            where: { projectId },
+        });
+        const totalCompleted = await client_1.default.userProject.count({
+            where: { projectId, status: "COMPLETED" },
+        });
+        await client_1.default.project.update({
+            where: { id: projectId },
+            data: {
+                completionRate: (totalCompleted / totalStarted) * 100,
+                submissionCount: { increment: 1 },
+            },
+        });
+        res.json({ success: true, data: progress });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.completeProject = completeProject;
+const getUserProgress = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const progress = await client_1.default.userProject.findMany({
+            where: { userId },
+            include: {
+                project: {
+                    select: { title: true, difficultyLevel: true },
+                },
+            },
+        });
+        res.json({ success: true, data: progress });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getUserProgress = getUserProgress;
+// Submissions
+const submitProject = async (req, res) => {
+    var _a;
+    const { id: projectId } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { repoUrl } = req.body;
+    try {
+        const submission = await client_1.default.submission.create({
+            data: {
+                userId,
+                projectId,
+                repoUrl,
+            },
+        });
+        res.status(201).json({ success: true, data: submission });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.submitProject = submitProject;
+const completeMilestone = async (req, res) => {
+    var _a;
+    const { id: projectId, milestoneId } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { difficultyMode } = req.body;
+    try {
+        const userProject = await client_1.default.userProject.findUnique({
+            where: {
+                userId_projectId_difficultyModeChosen: {
+                    userId,
+                    projectId,
+                    difficultyModeChosen: difficultyMode,
+                },
+            },
+        });
+        if (!userProject) {
+            return res.status(400).json({
+                success: false,
+                message: "Project not started by user in this mode",
+            });
+        }
+        const existingMilestone = await client_1.default.userMilestone.findUnique({
+            where: {
+                userId_milestoneId_userProjectId: {
+                    userId,
+                    milestoneId,
+                    userProjectId: userProject.id,
+                },
+            },
+        });
+        if (existingMilestone) {
+            return res.status(400).json({
+                success: false,
+                message: "Milestone already completed in this mode",
+            });
+        }
+        const milestone = await client_1.default.userMilestone.create({
+            data: {
+                userId,
+                milestoneId,
+                userProjectId: userProject.id,
+            },
+        });
+        res.status(201).json({ success: true, data: milestone });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.completeMilestone = completeMilestone;
+const getFeaturedProjects = async (req, res) => {
+    try {
+        const featuredProjects = await client_1.default.project.findMany({
+            take: 4,
+            orderBy: { submissionCount: "desc" },
+            include: {
+                createdBy: {
+                    select: { firstName: true, lastName: true },
+                },
+            },
+        });
+        res.json({ success: true, data: featuredProjects });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getFeaturedProjects = getFeaturedProjects;

dist/controllers/social/index.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shareProject = exports.getActivityFeed = exports.getFollowing = exports.getFollowers = exports.unfollowUser = exports.followUser = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const followUser = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { followingId } = req.body;
+    try {
+        if (userId === followingId) {
+            return res
+                .status(400)
+                .json({ success: false, message: "Cannot follow yourself" });
+        }
+        const existingFollow = await client_1.default.follow.findUnique({
+            where: { followerId_followingId: { followerId: userId, followingId } },
+        });
+        if (existingFollow) {
+            return res
+                .status(400)
+                .json({ success: false, message: "Already following this user" });
+        }
+        const follow = await client_1.default.follow.create({
+            data: { followerId: userId, followingId },
+        });
+        await client_1.default.notification.create({
+            data: {
+                userId: followingId,
+                type: "FOLLOW",
+                title: "New Follower",
+                message: "Someone started following you",
+                link: `/profile/${userId}`,
+            },
+        });
+        res.json({ success: true, data: follow });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.followUser = followUser;
+const unfollowUser = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { followingId } = req.params;
+    try {
+        await client_1.default.follow.delete({
+            where: { followerId_followingId: { followerId: userId, followingId } },
+        });
+        res.json({ success: true, message: "Unfollowed successfully" });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.unfollowUser = unfollowUser;
+const getFollowers = async (req, res) => {
+    const { userId } = req.params;
+    try {
+        const followers = await client_1.default.follow.findMany({
+            where: { followingId: userId },
+            include: {
+                follower: {
+                    select: {
+                        id: true,
+                        firstName: true,
+                        lastName: true,
+                        avatarUrl: true,
+                        xp: true,
+                    },
+                },
+            },
+        });
+        res.json({ success: true, data: followers });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getFollowers = getFollowers;
+const getFollowing = async (req, res) => {
+    const { userId } = req.params;
+    try {
+        const following = await client_1.default.follow.findMany({
+            where: { followerId: userId },
+            include: {
+                following: {
+                    select: {
+                        id: true,
+                        firstName: true,
+                        lastName: true,
+                        avatarUrl: true,
+                        xp: true,
+                    },
+                },
+            },
+        });
+        res.json({ success: true, data: following });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getFollowing = getFollowing;
+const getActivityFeed = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { page = 1, limit = 20 } = req.query;
+    try {
+        const following = await client_1.default.follow.findMany({
+            where: { followerId: userId },
+            select: { followingId: true },
+        });
+        const followingIds = following.map((f) => f.followingId);
+        const activities = await client_1.default.userProject.findMany({
+            where: {
+                userId: { in: followingIds },
+                status: "COMPLETED",
+            },
+            include: {
+                user: {
+                    select: {
+                        id: true,
+                        firstName: true,
+                        lastName: true,
+                        avatarUrl: true,
+                    },
+                },
+                project: {
+                    select: {
+                        id: true,
+                        title: true,
+                        slug: true,
+                    },
+                },
+            },
+            orderBy: { completedAt: "desc" },
+            take: Number(limit),
+            skip: (Number(page) - 1) * Number(limit),
+        });
+        res.json({ success: true, data: activities });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.getActivityFeed = getActivityFeed;
+const shareProject = async (req, res) => {
+    var _a;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    const { projectId, platform } = req.body;
+    try {
+        const project = await client_1.default.project.findUnique({
+            where: { id: projectId },
+        });
+        if (!project) {
+            return res
+                .status(404)
+                .json({ success: false, message: "Project not found" });
+        }
+        const shareUrl = `${process.env.CLIENT_URL}/projects/${project.slug}`;
+        const ogImageUrl = `${process.env.CLIENT_URL}/api/og-image/${project.slug}`;
+        const share = await client_1.default.socialShare.create({
+            data: {
+                userId,
+                projectId,
+                platform,
+                shareUrl,
+                ogImageUrl,
+            },
+        });
+        res.json({ success: true, data: { shareUrl, ogImageUrl, share } });
+    }
+    catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+exports.shareProject = shareProject;

dist/controllers/teams/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTeamProjects = exports.joinTeam = exports.createTeam = void 0;
+const client_1 = __importDefault(require("../../prisma/client"));
+const createTeam = async (req, res, next) => {
+    var _a;
+    const { name, projectId } = req.body;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const team = await client_1.default.team.create({
+            data: {
+                name,
+                projectId,
+                members: {
+                    create: {
+                        userId,
+                    },
+                },
+            },
+            include: {
+                members: true,
+            },
+        });
+        res.status(201).json({ success: true, data: team });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.createTeam = createTeam;
+const joinTeam = async (req, res, next) => {
+    var _a;
+    const { id: teamId } = req.params;
+    const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+    try {
+        const teamMember = await client_1.default.teamMember.create({
+            data: {
+                teamId,
+                userId,
+            },
+        });
+        res.status(201).json({ success: true, data: teamMember });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.joinTeam = joinTeam;
+const getTeamProjects = async (req, res, next) => {
+    const { id: teamId } = req.params;
+    try {
+        const team = await client_1.default.team.findUnique({
+            where: { id: teamId },
+            include: {
+                project: true,
+            },
+        });
+        if (!team)
+            return res
+                .status(404)
+                .json({ success: false, message: "Team not found" });
+        res.json({ success: true, data: team.project });
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.getTeamProjects = getTeamProjects;

dist/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appRoute = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+exports.appRoute = (0, express_1.default)();
+const auth_1 = __importDefault(require("./routes/auth"));
+const project_1 = __importDefault(require("./routes/project"));
+const user_1 = __importDefault(require("./routes/user"));
+const ai_1 = __importDefault(require("./routes/ai"));
+const code_review_1 = __importDefault(require("./routes/code-review"));
+const community_1 = __importDefault(require("./routes/community"));
+const teams_1 = __importDefault(require("./routes/teams"));
+const gamification_1 = __importDefault(require("./routes/gamification"));
+const paths_1 = __importDefault(require("./routes/paths"));
+const analytics_1 = __importDefault(require("./routes/analytics"));
+const social_1 = __importDefault(require("./routes/social"));
+const notifications_1 = __importDefault(require("./routes/notifications"));
+const events_1 = __importDefault(require("./routes/events"));
+const errorHandler_1 = require("./middlewares/errorHandler");
+const passport_1 = __importDefault(require("./utils/passport"));
+dotenv_1.default.config();
+const allowedOrigins = process.env.CLIENT_URL
+    ? process.env.CLIENT_URL.split(",").map((url) => url.trim())
+    : ["http://localhost:3002"];
+console.log("CORS Allowed Origins:", allowedOrigins);
+exports.appRoute.use((0, cors_1.default)({
+    origin: (origin, callback) => {
+        console.log("Incoming origin:", origin);
+        if (!origin ||
+            allowedOrigins.some((allowed) => origin.startsWith(allowed))) {
+            callback(null, true);
+        }
+        else {
+            console.warn("Blocked by CORS:", origin);
+            callback(new Error("Not allowed by CORS"));
+        }
+    },
+    credentials: true,
+    allowedHeaders: ["Content-Type", "Authorization"],
+    methods: ["GET", "POST", "PUT", "DELETE"],
+    exposedHeaders: ["Content-Disposition"],
+}));
+console.log("ENV:", process.env.CLIENT_URL);
+exports.appRoute.use(express_1.default.json({ limit: "50mb" }));
+exports.appRoute.use(express_1.default.urlencoded({ limit: "50mb", extended: true }));
+exports.appRoute.use((0, cookie_parser_1.default)());
+exports.appRoute.use(passport_1.default.initialize());
+exports.appRoute.get("/", (req, res) => {
+    res.send("Backend is working!");
+});
+exports.appRoute.use("/api/auth", auth_1.default);
+exports.appRoute.use("/api/projects", project_1.default);
+exports.appRoute.use("/api/user", user_1.default);
+exports.appRoute.use("/api/ai", ai_1.default);
+exports.appRoute.use("/api/code-review", code_review_1.default);
+exports.appRoute.use("/api/community", community_1.default);
+exports.appRoute.use("/api/teams", teams_1.default);
+exports.appRoute.use("/api/gamification", gamification_1.default);
+exports.appRoute.use("/api/paths", paths_1.default);
+exports.appRoute.use("/api/analytics", analytics_1.default);
+exports.appRoute.use("/api/social", social_1.default);
+exports.appRoute.use("/api/notifications", notifications_1.default);
+exports.appRoute.use("/api/events", events_1.default);
+exports.appRoute.use(errorHandler_1.errorHandler);

dist/middlewares/auth.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAuth = exports.authenticateToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const authenticateToken = (req, res, next) => {
+    var _a;
+    const token = req.cookies.token || ((_a = req.headers["authorization"]) === null || _a === void 0 ? void 0 : _a.split(" ")[1]);
+    if (!token)
+        res.sendStatus(401);
+    jsonwebtoken_1.default.verify(token, process.env.JWT_SECRET, (err, user) => {
+        if (err)
+            res.sendStatus(403);
+        req.user = user;
+        next();
+    });
+};
+exports.authenticateToken = authenticateToken;
+const checkAuth = async (req) => {
+    var _a;
+    let user = { id: "" };
+    const token = req.cookies.token || ((_a = req.headers["authorization"]) === null || _a === void 0 ? void 0 : _a.split(" ")[1]);
+    if (!token)
+        return null;
+    jsonwebtoken_1.default.verify(token, process.env.JWT_SECRET, (err, decoded) => {
+        user = decoded;
+    });
+    return user;
+};
+exports.checkAuth = checkAuth;

dist/middlewares/email.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendEmail = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const nodemailer_1 = __importDefault(require("nodemailer"));
+dotenv_1.default.config();
+const sendEmail = async (email, subject, html, text) => {
+    try {
+        const transporter = nodemailer_1.default.createTransport({
+            host: "smtp.gmail.com",
+            secure: true,
+            service: "gmail",
+            auth: {
+                user: process.env.EMAIL_USERNAME,
+                pass: process.env.EMAIL_PASSWORD,
+            },
+        });
+        const options = () => {
+            return {
+                from: `CV Builder <${process.env.EMAIL_USERNAME}>`,
+                to: email,
+                subject,
+                html: html,
+                text: text,
+            };
+        };
+        await transporter.sendMail(options());
+    }
+    catch (error) {
+        return error;
+    }
+};
+exports.sendEmail = sendEmail;

dist/middlewares/errorHandler.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const client_1 = require("@prisma/client");
+const errorHandler = (err, req, res, next) => {
+    var _a, _b;
+    console.error("Error:", err);
+    let status = 500;
+    let message = "Something went wrong. Please try again.";
+    let errors = undefined;
+    // Prisma Error Handling
+    if (err instanceof client_1.Prisma.PrismaClientKnownRequestError) {
+        switch (err.code) {
+            case "P2002": // Unique constraint violation
+                status = 409;
+                const target = ((_a = err.meta) === null || _a === void 0 ? void 0 : _a.target) || [];
+                message = `${target.join(", ")} already exists.`;
+                break;
+            case "P2025": // Record not found
+                status = 404;
+                message = ((_b = err.meta) === null || _b === void 0 ? void 0 : _b.cause) || "Record not found.";
+                break;
+            case "P2003": // Foreign key constraint violation
+                status = 400;
+                message = "Foreign key constraint failed.";
+                break;
+            default:
+                status = 400;
+                message = `Database error: ${err.message}`;
+        }
+    }
+    else if (err instanceof client_1.Prisma.PrismaClientValidationError) {
+        status = 400;
+        message = "Validation error in database request.";
+    }
+    else if (err.name === "ValidationError") {
+        status = 400;
+        message = err.message;
+    }
+    else if (err.status) {
+        status = err.status;
+        message = err.message;
+    }
+    res.status(status).json({
+        success: false,
+        message,
+        errors,
+        stack: process.env.NODE_ENV === "development" ? err.stack : undefined,
+    });
+};
+exports.errorHandler = errorHandler;

dist/middlewares/file.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upLoadFiles = exports.mapFiles = void 0;
+const dotenv = require("dotenv");
+dotenv.config();
+const cloudinary = require("cloudinary").v2;
+cloudinary.config({
+    cloud_name: process.env.CLOUDINARY_NAME,
+    api_key: process.env.CLOUDINARY_KEY,
+    api_secret: process.env.CLOUDINARY_SECRET,
+});
+const mapFiles = async (files) => {
+    let fls = [];
+    if (files && (files === null || files === void 0 ? void 0 : files.length) > 0) {
+        for await (let file of files) {
+            fls.push({
+                name: file === null || file === void 0 ? void 0 : file.name,
+                type: file === null || file === void 0 ? void 0 : file.type,
+                uri: (file === null || file === void 0 ? void 0 : file.uri.includes("res.cloudinary.com"))
+                    ? file === null || file === void 0 ? void 0 : file.uri
+                    : await (0, exports.upLoadFiles)(file === null || file === void 0 ? void 0 : file.uri, file === null || file === void 0 ? void 0 : file.name),
+            });
+        }
+    }
+    return fls;
+};
+exports.mapFiles = mapFiles;
+const upLoadFiles = async (file, fileName) => {
+    const uri = await cloudinary.uploader.upload(file, { public_id: fileName });
+    return uri === null || uri === void 0 ? void 0 : uri.secure_url;
+};
+exports.upLoadFiles = upLoadFiles;

dist/middlewares/generateOTP.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOTP = void 0;
+const generateOTP = () => {
+    let otp;
+    const otpDate = Date.now();
+    const numbers = 123456;
+    // const length: number = Math.floor(Math.random() * 2)
+    const randomNumbers = Math.floor(numbers + Math.random() * 100000);
+    otp = randomNumbers;
+    return { otp, otpDate };
+};
+exports.generateOTP = generateOTP;

dist/models/auth/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const { isEmail } = require("validator");
+const Schema = mongoose_1.default.Schema;
+const auth = new Schema({
+    firstName: { type: String, required: true, min: 3 },
+    lastName: { type: String, required: true, min: 3 },
+    email: {
+        type: String,
+        required: true,
+        unique: true,
+        lowercase: true,
+        validate: isEmail,
+    },
+    password: { type: String, required: true, min: 6 },
+    manageOTP: {
+        otp: { type: Number },
+        otpDate: { type: Number },
+    },
+}, { timestamps: true });
+const userAuth = mongoose_1.default.model("user", auth);
+exports.default = userAuth;

dist/models/project/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Project = void 0;
+const mongoose_1 = require("mongoose");
+const resourceSchema = new mongoose_1.Schema({
+    type: { type: String, enum: ["video", "article", "course"], required: true },
+    url: { type: String, required: true },
+    title: { type: String, required: true },
+});
+const projectSchema = new mongoose_1.Schema({
+    title: { type: String, required: true },
+    difficulty: {
+        type: String,
+        enum: ["beginner", "intermediate", "advanced"],
+        required: true,
+    },
+    description: { type: String, required: true },
+    requirements: [{ type: String }],
+    resources: [resourceSchema],
+}, { timestamps: true });
+exports.Project = (0, mongoose_1.model)("Project", projectSchema);

dist/prisma.config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// This file was generated by Prisma and assumes you have installed the following:
+// npm install --save-dev prisma dotenv
+require("dotenv/config");
+const config_1 = require("prisma/config");
+exports.default = (0, config_1.defineConfig)({
+    schema: "prisma/schema.prisma",
+    migrations: {
+        path: "prisma/migrations",
+    },
+    engine: "classic",
+    datasource: {
+        url: (0, config_1.env)("DATABASE_URL"),
+    },
+});

dist/prisma/client.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@prisma/client");
+const prisma = new client_1.PrismaClient();
+exports.default = prisma;

dist/prisma/migrations/generate-slugs.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@prisma/client");
+const prisma = new client_1.PrismaClient();
+function generateSlug(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+async function generateSlugs() {
+    const projects = await prisma.project.findMany({
+        where: { slug: null },
+    });
+    console.log(`Generating slugs for ${projects.length} projects...`);
+    for (const project of projects) {
+        let slug = generateSlug(project.title);
+        let counter = 1;
+        // Handle duplicates
+        while (await prisma.project.findUnique({ where: { slug } })) {
+            slug = `${generateSlug(project.title)}-${counter}`;
+            counter++;
+        }
+        await prisma.project.update({
+            where: { id: project.id },
+            data: { slug },
+        });
+        console.log(`✓ ${project.title} -> ${slug}`);
+    }
+    console.log("Done!");
+}
+generateSlugs()
+    .catch(console.error)
+    .finally(() => prisma.$disconnect());

dist/prisma/seed.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@prisma/client");
+const prisma = new client_1.PrismaClient();
+function generateSlug(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+const projects = [
+    {
+        title: "Landing Page Template",
+        slug: "landing-page-template",
+        difficultyLevel: client_1.Difficulty.BEGINNER,
+        description: "Build a responsive landing page with modern design principles",
+        technologies: ["HTML", "CSS"],
+        categories: ["Frontend", "Web Design"],
+        estimatedTime: "4-6 hours",
+        learningObjectives: [
+            "Responsive design",
+            "CSS Flexbox/Grid",
+            "Modern UI patterns",
+        ],
+        resourceLinks: [
+            { type: "video", url: "#", title: "HTML & CSS Crash Course" },
+        ],
+        featured: true,
+    },
+    {
+        title: "E-Commerce Dashboard",
+        slug: "ecommerce-dashboard",
+        difficultyLevel: client_1.Difficulty.INTERMEDIATE,
+        description: "Create dynamic admin dashboard with React and Chart.js",
+        technologies: ["React", "Chart.js"],
+        categories: ["Frontend", "Data Visualization"],
+        estimatedTime: "12-16 hours",
+        learningObjectives: [
+            "React state management",
+            "Data visualization",
+            "Dashboard UX",
+        ],
+        resourceLinks: [
+            { type: "article", url: "#", title: "React State Management Guide" },
+        ],
+        featured: true,
+    },
+    {
+        title: "E-Commerce REST API",
+        slug: "ecommerce-rest-api",
+        difficultyLevel: client_1.Difficulty.INTERMEDIATE,
+        description: "Develop a Node.js API with Express and MongoDB for product management",
+        technologies: ["Node.js", "Express", "MongoDB"],
+        categories: ["Backend", "API Development"],
+        estimatedTime: "16-20 hours",
+        learningObjectives: [
+            "RESTful API design",
+            "Database modeling",
+            "Authentication",
+        ],
+        resourceLinks: [
+            { type: "course", url: "#", title: "Node.js Fundamentals" },
+        ],
+        featured: false,
+    },
+    {
+        title: "Social Media Dashboard",
+        slug: "social-media-dashboard",
+        difficultyLevel: client_1.Difficulty.ADVANCED,
+        description: "Build real-time dashboard with React, GraphQL and WebSockets",
+        technologies: ["React", "GraphQL", "WebSockets"],
+        categories: ["Full-stack", "Real-time"],
+        estimatedTime: "24-32 hours",
+        learningObjectives: [
+            "GraphQL subscriptions",
+            "Real-time data",
+            "Advanced state management",
+        ],
+        resourceLinks: [
+            { type: "video", url: "#", title: "GraphQL Subscriptions" },
+        ],
+        featured: true,
+    },
+    {
+        title: "Portfolio Website",
+        slug: "portfolio-website",
+        difficultyLevel: client_1.Difficulty.BEGINNER,
+        description: "Create a personal portfolio with Next.js and Tailwind CSS",
+        technologies: ["Next.js", "Tailwind CSS"],
+        categories: ["Frontend", "Web Design"],
+        estimatedTime: "8-10 hours",
+        learningObjectives: [
+            "Next.js basics",
+            "Tailwind CSS",
+            "Portfolio best practices",
+        ],
+        resourceLinks: [
+            { type: "article", url: "#", title: "Next.js Deployment Guide" },
+        ],
+        featured: false,
+    },
+    {
+        title: "React Todo App with Firebase",
+        slug: "react-todo-firebase",
+        difficultyLevel: client_1.Difficulty.INTERMEDIATE,
+        description: "Create a collaborative todo application with real-time sync",
+        technologies: ["React", "Firebase"],
+        categories: ["Frontend", "Real-time"],
+        estimatedTime: "10-14 hours",
+        learningObjectives: [
+            "Firebase integration",
+            "Real-time sync",
+            "CRUD operations",
+        ],
+        resourceLinks: [
+            { type: "article", url: "#", title: "Firebase Realtime Database Guide" },
+        ],
+        featured: false,
+    },
+    {
+        title: "Authentication System",
+        slug: "authentication-system",
+        difficultyLevel: client_1.Difficulty.ADVANCED,
+        description: "Implement OAuth 2.0 flow with Node.js and Passport.js",
+        technologies: ["Node.js", "Passport.js"],
+        categories: ["Backend", "Security"],
+        estimatedTime: "20-24 hours",
+        learningObjectives: ["OAuth 2.0", "JWT tokens", "Security best practices"],
+        resourceLinks: [
+            { type: "course", url: "#", title: "Web Security Fundamentals" },
+        ],
+        featured: false,
+    },
+    {
+        title: "Mobile Recipe App",
+        slug: "mobile-recipe-app",
+        difficultyLevel: client_1.Difficulty.INTERMEDIATE,
+        description: "Build cross-platform recipe manager with React Native",
+        technologies: ["React Native"],
+        categories: ["Mobile", "Frontend"],
+        estimatedTime: "18-22 hours",
+        learningObjectives: [
+            "React Native basics",
+            "Mobile navigation",
+            "API integration",
+        ],
+        resourceLinks: [
+            { type: "video", url: "#", title: "React Native Navigation Tutorial" },
+        ],
+        featured: false,
+    },
+    {
+        title: "CMS Platform",
+        slug: "cms-platform",
+        difficultyLevel: client_1.Difficulty.ADVANCED,
+        description: "Headless CMS with Next.js and Sanity.io",
+        technologies: ["Next.js", "Sanity.io"],
+        categories: ["Full-stack", "CMS"],
+        estimatedTime: "28-36 hours",
+        learningObjectives: ["Headless CMS", "Content modeling", "Next.js ISR"],
+        resourceLinks: [
+            { type: "article", url: "#", title: "Sanity Studio Customization" },
+        ],
+        featured: true,
+    },
+    {
+        title: "AI Chat Interface",
+        slug: "ai-chat-interface",
+        difficultyLevel: client_1.Difficulty.ADVANCED,
+        description: "Build GPT-4 chatbot with streaming responses",
+        technologies: ["GPT-4", "Streaming"],
+        categories: ["AI/ML", "Full-stack"],
+        estimatedTime: "24-30 hours",
+        learningObjectives: ["LLM integration", "Streaming responses", "Chat UX"],
+        resourceLinks: [
+            { type: "course", url: "#", title: "LLM Integration Patterns" },
+        ],
+        featured: true,
+    },
+    {
+        title: "Real-time Chat Application",
+        slug: "realtime-chat-app",
+        difficultyLevel: client_1.Difficulty.INTERMEDIATE,
+        description: "Build chat app with Socket.io and React",
+        technologies: ["Socket.io", "React"],
+        categories: ["Full-stack", "Real-time"],
+        estimatedTime: "14-18 hours",
+        learningObjectives: [
+            "WebSocket protocol",
+            "Real-time messaging",
+            "Chat features",
+        ],
+        resourceLinks: [
+            { type: "video", url: "#", title: "WebSocket Fundamentals" },
+        ],
+        featured: false,
+    },
+    {
+        title: "Serverless API Gateway",
+        slug: "serverless-api-gateway",
+        difficultyLevel: client_1.Difficulty.ADVANCED,
+        description: "Create REST API using AWS Lambda & API Gateway",
+        technologies: ["AWS Lambda", "API Gateway"],
+        categories: ["Backend", "Cloud"],
+        estimatedTime: "20-26 hours",
+        learningObjectives: [
+            "Serverless architecture",
+            "AWS services",
+            "API design",
+        ],
+        resourceLinks: [
+            { type: "article", url: "#", title: "AWS Serverless Patterns" },
+        ],
+        featured: false,
+    },
+    {
+        title: "E-commerce Product Search",
+        slug: "ecommerce-product-search",
+        difficultyLevel: client_1.Difficulty.ADVANCED,
+        description: "Implement search functionality with Algolia",
+        technologies: ["Algolia"],
+        categories: ["Frontend", "Search"],
+        estimatedTime: "16-20 hours",
+        learningObjectives: [
+            "Search algorithms",
+            "Algolia integration",
+            "Search UX",
+        ],
+        resourceLinks: [
+            { type: "course", url: "#", title: "Search Engine Optimization" },
+        ],
+        featured: false,
+    },
+    {
+        title: "Mobile Payment Integration",
+        slug: "mobile-payment-integration",
+        difficultyLevel: client_1.Difficulty.ADVANCED,
+        description: "Add Stripe payments to React Native app",
+        technologies: ["React Native", "Stripe"],
+        categories: ["Mobile", "Payments"],
+        estimatedTime: "18-24 hours",
+        learningObjectives: ["Payment processing", "Stripe API", "Mobile security"],
+        resourceLinks: [
+            { type: "video", url: "#", title: "Mobile Payment Systems" },
+        ],
+        featured: false,
+    },
+    {
+        title: "Data Visualization Dashboard",
+        slug: "data-visualization-dashboard",
+        difficultyLevel: client_1.Difficulty.INTERMEDIATE,
+        description: "Create analytics dashboard with D3.js",
+        technologies: ["D3.js"],
+        categories: ["Frontend", "Data Visualization"],
+        estimatedTime: "14-18 hours",
+        learningObjectives: [
+            "D3.js fundamentals",
+            "Data visualization",
+            "Interactive charts",
+        ],
+        resourceLinks: [{ type: "article", url: "#", title: "D3.js Essentials" }],
+        featured: false,
+    },
+];
+async function main() {
+    console.log("Start seeding...");
+    // Create a default user if not exists
+    const user = await prisma.user.upsert({
+        where: { email: "admin@devresource.com" },
+        update: {},
+        create: {
+            email: "admin@devresource.com",
+            firstName: "Admin",
+            lastName: "User",
+            password: "password123", // In a real app, this should be hashed
+            role: "ADMIN",
+        },
+    });
+    console.log(`Created user with id: ${user.id}`);
+    for (const project of projects) {
+        const createdProject = await prisma.project.upsert({
+            where: { slug: project.slug },
+            update: {
+                ...project,
+                createdById: user.id,
+            },
+            create: {
+                ...project,
+                createdById: user.id,
+            },
+        });
+        console.log(`Created project with id: ${createdProject.id}`);
+    }
+    console.log("Seeding finished.");
+}
+main()
+    .catch((e) => {
+    console.error(e);
+    process.exit(1);
+})
+    .finally(async () => {
+    await prisma.$disconnect();
+});

dist/routes/ai.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const ai_1 = require("../controllers/ai");
+const auth_1 = require("../middlewares/auth");
+const router = (0, express_1.Router)();
+router.post("/chat", auth_1.authenticateToken, ai_1.chatWithAI);
+router.get("/chat", auth_1.authenticateToken, ai_1.getAllChatMessages);
+router.get("/chat/history/:projectId", auth_1.authenticateToken, ai_1.getChatHistory);
+router.post("/hint-request", auth_1.authenticateToken, ai_1.requestHint);
+exports.default = router;

dist/routes/analytics.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const analytics_1 = require("../controllers/analytics");
+const auth_1 = require("../middlewares/auth");
+const router = (0, express_1.Router)();
+router.get("/user", auth_1.authenticateToken, analytics_1.getUserAnalytics);
+router.get("/admin", auth_1.authenticateToken, analytics_1.getAdminAnalytics);
+exports.default = router;

dist/routes/auth.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const auth_1 = require("../controllers/auth");
+const auth_2 = require("../middlewares/auth");
+const passport_1 = __importDefault(require("../utils/passport"));
+const router = express_1.default.Router();
+router.post("/register", auth_1.signUp);
+router.post("/login", auth_1.login);
+router.post("/logout", auth_1.logout);
+router.get("/me", auth_2.authenticateToken, auth_1.me);
+router.post("/update/:id", auth_2.authenticateToken, auth_1.updateUser);
+router.get("/user/:id", auth_2.authenticateToken, auth_1.getUser);
+router.post("/forgetPassword", auth_1.forgetPassword);
+router.post("/verifyOtp", auth_1.verifyOTP);
+router.post("/resetPassword", auth_1.resetPassword);
+router.get("/google", passport_1.default.authenticate("google", { scope: ["profile", "email"] }));
+router.get("/google/callback", passport_1.default.authenticate("google", {
+    session: false,
+    failureRedirect: `${process.env.CLIENT_URL}/auth/signin?error=auth_failed`,
+}), auth_1.googleAuthCallback);
+router.get("/github", passport_1.default.authenticate("github", { scope: ["user:email"] }));
+router.get("/github/callback", passport_1.default.authenticate("github", {
+    session: false,
+    failureRedirect: `${process.env.CLIENT_URL}/auth/signin?error=auth_failed`,
+}), auth_1.githubAuthCallback);
+exports.default = router;

dist/routes/code-review.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const code_review_1 = require("../controllers/code-review");
+const auth_1 = require("../middlewares/auth");
+const router = (0, express_1.Router)();
+router.post("/analyze", auth_1.authenticateToken, code_review_1.analyzeCode);
+router.get("/:id", auth_1.authenticateToken, code_review_1.getSubmissionReview);
+exports.default = router;

dist/routes/community.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const community_1 = require("../controllers/community");
+const auth_1 = require("../middlewares/auth");
+const router = (0, express_1.Router)();
+router.get("/submissions/public", community_1.getPublicSubmissions);
+router.post("/submissions/:id/comment", auth_1.authenticateToken, community_1.commentOnSubmission);
+router.post("/submissions/:id/vote", auth_1.authenticateToken, community_1.voteOnSubmission);
+router.get("/forum/threads", community_1.getForumThreads);
+router.post("/forum/threads", auth_1.authenticateToken, community_1.createForumThread);
+exports.default = router;

dist/routes/events.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const events_1 = require("../controllers/events");
+const auth_1 = require("../middlewares/auth");
+const router = express_1.default.Router();
+router.post("/", auth_1.authenticateToken, events_1.createEvent);
+router.get("/", events_1.getEvents);
+router.get("/:id", events_1.getEvent);
+router.post("/:eventId/join", auth_1.authenticateToken, events_1.joinEvent);
+router.delete("/:eventId/leave", auth_1.authenticateToken, events_1.leaveEvent);
+router.patch("/:eventId/score/:userId", auth_1.authenticateToken, events_1.updateEventScore);
+router.get("/:eventId/leaderboard", events_1.getLeaderboard);
+exports.default = router;

dist/routes/gamification.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const gamification_1 = require("../controllers/gamification");
+const auth_1 = require("../middlewares/auth");
+const router = (0, express_1.Router)();
+router.get("/leaderboard", gamification_1.getLeaderboard);
+router.get("/achievements", auth_1.authenticateToken, gamification_1.getUserAchievements);
+exports.default = router;

dist/routes/notifications.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const notifications_1 = require("../controllers/notifications");
+const auth_1 = require("../middlewares/auth");
+const router = express_1.default.Router();
+router.get("/", auth_1.authenticateToken, notifications_1.getNotifications);
+router.patch("/:notificationId/read", auth_1.authenticateToken, notifications_1.markAsRead);
+router.patch("/read-all", auth_1.authenticateToken, notifications_1.markAllAsRead);
+router.delete("/:notificationId", auth_1.authenticateToken, notifications_1.deleteNotification);
+exports.default = router;

dist/routes/paths.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const paths_1 = require("../controllers/paths");
+const auth_1 = require("../middlewares/auth");
+const router = (0, express_1.Router)();
+router.get("/", paths_1.getLearningPaths);
+router.get("/:id/progress", auth_1.authenticateToken, paths_1.getPathProgress);
+router.post("/:id/start", auth_1.authenticateToken, paths_1.startPath);
+exports.default = router;

dist/routes/project.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const projects_1 = require("../controllers/projects");
+const auth_1 = require("../middlewares/auth");
+const router = (0, express_1.Router)();
+router.get("/", projects_1.getProjects);
+router.get("/progress", auth_1.authenticateToken, projects_1.getUserProgress);
+router.get("/featured", projects_1.getFeaturedProjects);
+router.get("/:id", projects_1.getProjectById);
+router.post("/", auth_1.authenticateToken, projects_1.createProject);
+router.put("/:id", auth_1.authenticateToken, projects_1.updateProject);
+router.delete("/:id", auth_1.authenticateToken, projects_1.deleteProject);
+// User Progress
+router.post("/:id/start", auth_1.authenticateToken, projects_1.startProject);
+router.put("/:id/progress", auth_1.authenticateToken, projects_1.updateProgress);
+router.post("/:id/complete", auth_1.authenticateToken, projects_1.completeProject);
+// Milestones
+router.post("/:id/milestones/:milestoneId/complete", auth_1.authenticateToken, projects_1.completeMilestone);
+// Submissions
+router.post("/:id/submit", auth_1.authenticateToken, projects_1.submitProject);
+exports.default = router;

dist/routes/social.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const social_1 = require("../controllers/social");
+const auth_1 = require("../middlewares/auth");
+const router = express_1.default.Router();
+router.post("/follow", auth_1.authenticateToken, social_1.followUser);
+router.delete("/unfollow/:followingId", auth_1.authenticateToken, social_1.unfollowUser);
+router.get("/followers/:userId", auth_1.authenticateToken, social_1.getFollowers);
+router.get("/following/:userId", auth_1.authenticateToken, social_1.getFollowing);
+router.get("/activity-feed", auth_1.authenticateToken, social_1.getActivityFeed);
+router.post("/share", auth_1.authenticateToken, social_1.shareProject);
+exports.default = router;

dist/routes/teams.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const teams_1 = require("../controllers/teams");
+const auth_1 = require("../middlewares/auth");
+const router = (0, express_1.Router)();
+router.post("/create", auth_1.authenticateToken, teams_1.createTeam);
+router.post("/:id/join", auth_1.authenticateToken, teams_1.joinTeam);
+router.get("/:id/projects", auth_1.authenticateToken, teams_1.getTeamProjects);
+exports.default = router;

dist/routes/user.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const projects_1 = require("../controllers/projects");
+const auth_1 = require("../middlewares/auth");
+const router = (0, express_1.Router)();
+router.get("/progress", auth_1.authenticateToken, projects_1.getUserProgress);
+router.post("/projects/:id/start", auth_1.authenticateToken, projects_1.startProject);
+router.put("/projects/:id/progress", auth_1.authenticateToken, projects_1.updateProgress);
+router.post("/projects/:id/complete", auth_1.authenticateToken, projects_1.completeProject);
+exports.default = router;