Feature/integrate zod for request validation

backend/Input_validators/ValidateAchievement.js

@@ -0,0 +1,22 @@
+const { z } = require('zod');
+const { handleValidationError } = require('./ValidateQuestions');
+
+const savedAchievementsSchema = z.object({
+  unlockedAchievements: z.array(z.string(), {
+    required_error: "unlockedAchievements must be an array",
+    invalid_type_error: "unlockedAchievements must be an array of strings",
+  }),
+});
+
+const validateSavedAchievements = (req, res, next) => {
+  try {
+    savedAchievementsSchema.parse(req.body);
+    next();
+  } catch (e) {
+    return handleValidationError(res, e);
+  }
+};
+
+module.exports = {
+  validateSavedAchievements,
+};

backend/Input_validators/ValidateAi.js

@@ -0,0 +1,56 @@
+const { z } = require("zod");
+const { handleValidationError } = require("./ValidateQuestions");
+
+// Schema for interview questions request
+const generateInterviewQuestionsSchema = z.object({
+  role: z.string().min(1, "Role is required"),
+  experience: z.string().min(1, "Experience is required"),
+  topicsToFocus: z.array(z.string()).min(1, "At least one topic is required"),
+  numberOfQuestions: z.number().int().positive("Number of questions must be positive"),
+});
+
+// Schema for concept explanation request
+const generateConceptExplanationSchema = z.object({
+  question: z.string().min(1, "Question is required"),
+});
+
+// Schema for interview tips request
+const generateInterviewTipsSchema = z.object({
+  role: z.string().min(1, "Role is required"),
+  experience: z.string().min(1, "Experience is required"),
+});
+
+
+const validateGenerateInterviewQuestions = (req,res,next)=>{
+
+    try {
+        generateInterviewQuestionsSchema.parse(req.body);
+        next();
+    } catch (error) {
+        return handleValidationError(res, error);
+    }
+}
+
+const validateGenerateConceptExplanation = (req,res,next)=>{
+
+    try {
+        generateConceptExplanationSchema.parse(req.body);
+        next();
+    } catch (error) {
+        return handleValidationError(res, error);
+}}
+
+const validateGenerateInterviewTips = (req, res, next) => {
+  try {
+    generateInterviewTipsSchema.parse(req.body);
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+module.exports = {
+  validateGenerateInterviewQuestions,
+  validateGenerateConceptExplanation,
+  validateGenerateInterviewTips,
+};

backend/Input_validators/ValidateAuth.js

@@ -0,0 +1,97 @@
+const { z } = require("zod");
+const { handleValidationError } = require("./ValidateQuestions");
+
+const registerUserZod = z.object({
+  name: z.string().min(4, "Length of the name should be minimum 4").trim(),
+  email: z.string().email("Enter a valid email").trim(),
+  password: z.string().trim(),
+  profileImageUrl: z.string().url("Enter a valid URL").trim().optional()
+});
+
+
+const validateUserSignup = (req, res, next) => {
+  try {
+    registerUserZod.parse(req.body);
+    next();
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return res.status(400).json({
+        success: false,
+        message: "Validation failed",
+        errors: err.issues.map(issue => ({
+          field: issue.path.join("."),
+          message: issue.message,
+        })),
+      }); 
+    }
+    // fallback for other errors
+    return res.status(500).json({ success: false, message: "Internal server error" });
+}
+};
+
+const loginUserZod = z.object({
+    email : z.string().email("Enter a valid email"),
+    password : z.string().min(8)
+})
+
+const validateUserLogin = (req, res, next) => {
+  try {
+    loginUserZod.parse(req.body);
+    next();
+  } catch (err) {
+     return handleValidationError(res, error);
+  }
+};
+
+const refreshTokenZod = z.object({
+  refreshToken : z.string("Must be an string")
+})
+
+const validateRefreshToken = (req, res, next) => {
+  try {
+    refreshTokenZod.parse(req.body);
+    next();
+  } catch (err) {
+    return res.status(400).json({
+      success: false,
+      message: "Validation failed",
+      errors: err.errors.map(e => ({
+        field: e.path.join("."),
+        message: e.message,
+      })),
+    });
+  }
+};
+
+const resendVerificationZod = z.object({
+  email : z.string().email()
+})
+
+const validateResendEmail = (req,res,next)=>{
+
+  try{
+
+    resendVerificationZod.parse(req.body);
+    next();
+
+  }
+  catch(err){
+
+    return res.status(400).json({
+      success: false,
+      message: "Validation failed",
+      errors: err.errors.map(e => ({
+        field: e.path.join("."),
+        message: e.message,
+      })),
+    });
+
+  }
+}
+
+module.exports = {
+    validateUserLogin,
+    validateUserSignup,
+    validateRefreshToken,
+    validateResendEmail
+}

backend/Input_validators/ValidateQuestions.js

@@ -0,0 +1,72 @@
+const { z } = require("zod");
+
+// Schema for adding questions to a session
+const addQuestionToSessionSchema = z.object({
+  sessionId: z.string().min(1, "Session ID is required"),
+  questions: z.array(
+    z.object({
+      question: z.string().min(1, "Question text is required"),
+      answer: z.string().min(1, "Answer text is required"),
+    })
+  ).min(1, "At least one question is required"),
+});
+
+// Schema for toggling pin (params only)
+const togglePinQuestionSchema = z.object({
+  id: z.string().min(1, "Question ID is required"),
+});
+
+// Schema for updating note
+const updateQuestionNoteSchema = z.object({
+  note: z.string().min(1, "Note cannot be empty"),
+});
+
+
+// Helper for consistent error responses
+const handleValidationError = (res, error) => {
+  return res.status(400).json({
+    success: false,
+    message: "Validation failed",
+    errors: error.errors.map(e => ({
+      field: e.path.join("."),
+      message: e.message,
+    })),
+  });
+};
+
+// Middleware for addQuestionToSession
+const validateAddQuestionToSession = (req, res, next) => {
+  try {
+    addQuestionToSessionSchema.parse(req.body);
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+// Middleware for togglePinQuestion (params)
+const validateTogglePinQuestion = (req, res, next) => {
+  try {
+    togglePinQuestionSchema.parse(req.params);
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+// Middleware for updateQuestionNote
+const validateUpdateQuestionNote = (req, res, next) => {
+  try {
+    updateQuestionNoteSchema.parse(req.body);
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+module.exports = {
+  validateAddQuestionToSession,
+  validateTogglePinQuestion,
+  validateUpdateQuestionNote,
+  handleValidationError
+};

backend/Input_validators/ValidateResume.js

@@ -0,0 +1,60 @@
+const { z } = require("zod");
+const { handleValidationError } = require('./ValidateQuestions')
+
+// Schema for compileResume request
+const compileResumeSchema = z.object({
+  code: z.string().min(1, "LaTeX code is required"),
+});
+
+// Schema for analyzeResume request
+const analyzeResumeSchema = z.object({
+  targetRole: z.string().min(1, "Target role is required").optional(),
+});
+
+// Schema for saveResume request
+const saveResumeSchema = z.object({
+  title: z.string().min(1, "Title is required"),
+  latexCode: z.string().min(1, "LaTeX code is required"),
+  resumeId: z.string().optional(),
+});
+
+
+// Middleware for compileResume
+const validateCompileResume = (req, res, next) => {
+  try {
+    compileResumeSchema.parse(req.body);
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+// Middleware for analyzeResume
+const validateAnalyzeResume = (req, res, next) => {
+  try {
+    analyzeResumeSchema.parse(req.body);
+    // also ensure file is uploaded
+    if (!req.file) {
+      return res.status(400).json({ success: false, message: "No resume file uploaded" });
+    }
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+// Middleware for saveResume
+const validateSaveResume = (req, res, next) => {
+  try {
+    saveResumeSchema.parse(req.body);
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+module.exports = {
+  validateCompileResume,
+  validateAnalyzeResume,
+  validateSaveResume,
+};

backend/Input_validators/ValidateSession.js

@@ -0,0 +1,63 @@
+const { z } = require("zod");
+const { handleValidationError } = require("./ValidateQuestions");
+
+// Schema for creating a session
+const createSessionSchema = z.object({
+  role: z.string().min(1, "Role is required"),
+  experience: z.string().min(1, "Experience is required"),
+  topicsToFocus: z.array(z.string()).min(1, "At least one topic is required"),
+  description: z.string().optional(),
+  question: z.array(
+    z.object({
+      question: z.string().min(1, "Question text is required"),
+      answer: z.string().min(1, "Answer text is required"),
+    })
+  ).optional(),
+});
+
+// Schema for getting a session by ID (params)
+const getSessionByIdSchema = z.object({
+  id: z.string().min(1, "Session ID is required"),
+});
+
+// Schema for deleting a session (params)
+const deleteSessionSchema = z.object({
+  id: z.string().min(1, "Session ID is required"),
+});
+
+
+// Middleware for createSession
+const validateCreateSession = (req, res, next) => {
+  try {
+    createSessionSchema.parse(req.body);
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+// Middleware for getSessionById
+const validateGetSessionById = (req, res, next) => {
+  try {
+    getSessionByIdSchema.parse(req.params);
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+// Middleware for deleteSession
+const validateDeleteSession = (req, res, next) => {
+  try {
+    deleteSessionSchema.parse(req.params);
+    next();
+  } catch (error) {
+    return handleValidationError(res, error);
+  }
+};
+
+module.exports = {
+  validateCreateSession,
+  validateGetSessionById,
+  validateDeleteSession,
+};