Fix: Improve data integrity, validation, and performance across models & APIs

app/api/assignments/route.ts

@@ -4,13 +4,16 @@ import { connectDB } from '@/lib/mongodb'
 import { Assignment } from '@/models/Assignment'
 import { z } from 'zod'
 
+const SUBJECTS = ['Mathematics', 'Data Structures', 'Operating Systems', 'DBMS', 'Computer Networks'] as const;
+const CLASSES = ['CS-A', 'CS-B'] as const;
+
 const AssignmentSchema = z.object({
-  title: z.string().min(1),
-  description: z.string().optional(),
-  subject: z.string().min(1),
-  class: z.string().min(1),
-  deadline: z.string().min(1),
-  maxMarks: z.number().min(1).optional(),
+  title: z.string().trim().min(3),
+  description: z.string().max(1000).optional(),
+  subject: z.enum(SUBJECTS),
+  class: z.enum(CLASSES),
+  deadline: z.string().refine((value) => new Date(value) > new Date(), 'Deadline must be in the future'),
+  maxMarks: z.number().min(1).max(1000).optional(),
   status: z.enum(['active', 'closed']).optional(),
   kanbanStatus: z.enum(['todo', 'in_progress', 'submitted']).optional(),
 })

app/api/grades/route.ts

@@ -3,9 +3,15 @@ import { NextRequest, NextResponse } from 'next/server'
 import { connectDB } from '@/lib/mongodb'
 import { Grade } from '@/models/Grade'
 import { z } from 'zod'
+import mongoose from 'mongoose'
+import { Teacher } from '@/models/Teacher'
 
+async function findTeacherByClerkId(userId: string){ 
+  return Teacher.findOne({ clerkId: userId }).select('_id').lean()
+};
+
 const GradeSchema = z.object({
-  studentId: z.string().min(1),
+  studentId: z.string().regex(/^[0-9a-fA-F]{24}$/, 'Invalid studentId'),
   studentName: z.string().min(1),
   subject: z.string().min(1),
   marks: z.number().min(0),
@@ -21,7 +27,7 @@ const GradeSchema = z.object({
 
 function calcGrade(marks: number, max: number): string {
   const pct = (marks / max) * 100
-  if (pct > 90) return 'A+'
+  if (pct >= 90) return 'A+'
   if (pct >= 80) return 'A'
   if (pct >= 70) return 'B+'
   if (pct >= 60) return 'B'
@@ -35,20 +41,29 @@ export async function GET(req: NextRequest) {
   if (!userId) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
 
   try {
-    await connectDB()
+    await connectDB();
+
+    const teacher = await findTeacherByClerkId(userId);
+    if (!teacher) return NextResponse.json({ error: 'Teacher not found' }, { status: 404 });
+
     const { searchParams } = new URL(req.url)
     const studentId = searchParams.get('studentId')
     const subject = searchParams.get('subject')
 
-    const query: Record<string, unknown> = { teacherId: userId }
-    if (studentId) query.studentId = studentId
+    const query: Record<string, unknown> = { teacherId: teacher._id };
+
+  if (studentId) {
+     if (!mongoose.Types.ObjectId.isValid(studentId)) return NextResponse.json({ error: 'Invalid studentId' }, { status: 400 });
+     query.studentId = new mongoose.Types.ObjectId(studentId)
+  };
+
     if (subject) query.subject = subject
 
     const grades = await Grade.find(query).sort({ createdAt: -1 }).lean()
     return NextResponse.json(grades)
   } catch (error) {
     console.error('GET /api/grades error:', error instanceof Error ? error.message : error)
-    return NextResponse.json({ error: error instanceof Error ? error.stack : 'Internal server error' }, { status: 500 })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
   }
 }
 
@@ -58,6 +73,9 @@ export async function POST(req: NextRequest) {
 
   try {
     await connectDB()
+
+     const teacher = await findTeacherByClerkId(userId);
+     if (!teacher) return NextResponse.json({ error: 'Teacher not found' }, { status: 404 });
 
     let body
     try {
@@ -69,20 +87,24 @@ export async function POST(req: NextRequest) {
     const parsed = GradeSchema.safeParse(body)
     if (!parsed.success) return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 })
 
-    const data = parsed.data
-    const max = data.maxMarks!
+    const data = {
+      ...parsed.data,
+      studentName: parsed.data.studentName.trim(),
+      subject: parsed.data.subject.trim(),
+    };
+    const max = data.maxMarks ?? 100;
     const term = data.term ?? 'Term 1'
 
-    const grade = Grade.findOneAndUpdate(
-      { teacherId: userId, studentId: data.studentId, subject: data.subject, term },
-      { $set: { ...data, term, teacherId: userId, grade: calcGrade(data.marks, max) } },
+    const grade = await Grade.findOneAndUpdate(
+      { teacherId: teacher._id, studentId: new mongoose.Types.ObjectId(data.studentId), subject: data.subject, term },
+      { $set: { ...data, term, teacherId: teacher._id, grade: calcGrade(data.marks, max) } },
       { upsert: true, new: true }
     )
     return NextResponse.json(grade, { status: 201 })
   } catch (error) {
     if (error instanceof Error) {
       console.error('POST /api/grades error:', error.message)
     }
-    return NextResponse.json({ error: error instanceof Error ? error.stack : 'Internal server error' }, { status: 500 })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
   }
 }

app/api/profile/route.ts

@@ -20,6 +20,9 @@ export async function GET(req: NextRequest) {
 
     if (!teacher) {
       const clerkUser = await currentUser()
+      if (!clerkUser) {
+        return NextResponse.json({ error: "User not found" }, { status: 404 });
+      }
       const created = await Teacher.create({
         clerkId: userId,
         name: clerkUser?.fullName ?? '',
@@ -60,9 +63,15 @@ export async function PUT(req: NextRequest) {
     if (department !== undefined && typeof department !== 'string') {
       return NextResponse.json({ error: 'department must be a string' }, { status: 400 })
     }
-    if (!Array.isArray(subjects) || !subjects.every((s) => typeof s === 'string')) {
+
+   if (
+     !Array.isArray(subjects) ||
+     subjects.length === 0 ||
+     !subjects.every((s: unknown) => typeof s === 'string' && s.trim().length > 0)
+    ) {
       return NextResponse.json({ error: 'subjects must be an array of strings' }, { status: 400 })
     }
+
     if (phone !== undefined && typeof phone !== 'string') {
       return NextResponse.json({ error: 'phone must be a string' }, { status: 400 })
     }
@@ -77,7 +86,7 @@ export async function PUT(req: NextRequest) {
           (entry: unknown) =>
             entry !== null &&
             typeof entry === 'object' &&
-            typeof (entry as Record<string, unknown>).year === 'string' &&
+            typeof (entry as Record<string, unknown>).year === 'string'  &&
             typeof (entry as Record<string, unknown>).title === 'string',
         )
       ) {
@@ -88,17 +97,20 @@ export async function PUT(req: NextRequest) {
       }
     }
 
-    const updatePayload: Record<string, unknown> = { name, subjects }
+    const updatePayload: Record<string, unknown> = {
+      name: name.trim(),
+      subjects: subjects.map((s) => s.trim()),
+    };
     if (department !== undefined) updatePayload.department = department
-    if (phone !== undefined) updatePayload.phone = phone
-    if (bio !== undefined) updatePayload.bio = bio
+    if (phone !== undefined) updatePayload.phone = phone.trim()
+    if (bio !== undefined) updatePayload.bio = bio.trim()
     if (academicHistory !== undefined) updatePayload.academicHistory = academicHistory
 
     const teacher = await Teacher.findOneAndUpdate(
       { clerkId: userId },
       { $set: updatePayload },
-      { new: true }
-    )
+      { new: true, runValidators: true },
+    );
 
     if (!teacher) {
       return NextResponse.json({ error: 'Teacher not found' }, { status: 404 })

models/Announcement.ts

@@ -1,28 +1,42 @@
-import mongoose, { Schema, model, models } from 'mongoose'
+import mongoose, { Schema, model, models } from "mongoose";
 
 export interface IAnnouncement {
-  _id: mongoose.Types.ObjectId
-  teacherId: string
-  title: string
-  content: string
-  audience: string
-  category: 'academic' | 'events' | 'admin' | 'general'
-  pinned: boolean
-  createdAt: Date
-  updatedAt: Date
+  _id: mongoose.Types.ObjectId;
+  teacherId: mongoose.Types.ObjectId;
+  title: string;
+  content: string;
+  audience: string;
+  category: "academic" | "events" | "admin" | "general";
+  pinned: boolean;
+  createdAt: Date;
+  updatedAt: Date;
 }
 
 const AnnouncementSchema = new Schema<IAnnouncement>(
   {
-    teacherId: { type: String, required: true, index: true },
-    title: { type: String, required: true },
-    content: { type: String, required: true },
-    audience: { type: String, default: 'All' },
-    category: { type: String, enum: ['academic', 'events', 'admin', 'general'], default: 'general' },
+    teacherId: {
+      type: Schema.Types.ObjectId,
+      ref: "Teacher",
+      required: true,
+      index: true,
+    },
+    title: { type: String, required: true, trim: true, minlength: 3 },
+    content: { type: String, required: true, trim: true, minlength: 5 },
+    audience: { type: String, default: "All", trim: true },
+    category: {
+      type: String,
+      enum: ["academic", "events", "admin", "general"],
+      default: "general",
+    },
     pinned: { type: Boolean, default: false },
   },
-  { timestamps: true }
-)
+  { timestamps: true },
+);
+
+AnnouncementSchema.index({ teacherId: 1, pinned: 1 });
+
+AnnouncementSchema.index({ teacherId: 1, createdAt: -1 });
 
 export const Announcement =
-  models.Announcement ?? model<IAnnouncement>('Announcement', AnnouncementSchema)
+  models.Announcement ??
+  model<IAnnouncement>("Announcement", AnnouncementSchema);

models/Assignment.ts

@@ -2,7 +2,7 @@ import mongoose, { Schema, model, models } from 'mongoose'
 
 export interface IAssignment {
   _id: mongoose.Types.ObjectId
-  teacherId: string
+  teacherId: mongoose.Types.ObjectId
   title: string
   description: string
   subject: string
@@ -17,17 +17,38 @@ export interface IAssignment {
 
 const AssignmentSchema = new Schema<IAssignment>(
   {
-    teacherId: { type: String, required: true, index: true },
-    title: { type: String, required: true },
-    description: { type: String, default: '' },
-    subject: { type: String, required: true },
-    class: { type: String, required: true },
-    deadline: { type: Date, required: true },
+    teacherId: { type: Schema.Types.ObjectId, ref: 'Teacher', required: true, index: true },
+    title: { type: String, required: true, trim: true, minlength: 3 },
+    description: { type: String, default: '', maxlength: 1000 },
+    subject: {
+      type: String,
+      enum: ['Mathematics', 'Data Structures', 'Operating Systems', 'DBMS', 'Computer Networks'],
+      required: true
+    },
+    class: {
+      type: String,
+      enum: ['CS-A', 'CS-B'],
+      required: true
+    },
+    deadline: {
+      type: Date,
+      required: true,
+      validate: {
+        validator: (value: Date) => value > new Date(),
+        message: 'Deadline must be in the future'
+      }
+    },
     status: { type: String, enum: ['active', 'closed'], default: 'active' },
     kanbanStatus: { type: String, enum: ['todo', 'in_progress', 'submitted'], default: 'todo' },
-    maxMarks: { type: Number, default: 100 },
+    maxMarks: { type: Number, default: 100, min: 1, max: 1000 },
   },
   { timestamps: true }
 )
 
-export const Assignment = models.Assignment ?? model<IAssignment>('Assignment', AssignmentSchema)
+// ✅ Correct indexes
+AssignmentSchema.index({ teacherId: 1, class: 1 })
+AssignmentSchema.index({ status: 1 })
+AssignmentSchema.index({ deadline: 1 })
+
+export const Assignment =
+  models.Assignment ?? model<IAssignment>('Assignment', AssignmentSchema)

models/Attendance.ts

@@ -2,9 +2,9 @@ import mongoose, { Schema, model, models } from 'mongoose'
 
 export interface IAttendance {
   _id: mongoose.Types.ObjectId
-  teacherId: string
+  teacherId: mongoose.Types.ObjectId
   studentId: mongoose.Types.ObjectId
-  studentName: string
+  // removed the studentName
   class: string
   date: string
   status: 'present' | 'absent' | 'late'
@@ -14,16 +14,27 @@ export interface IAttendance {
 
 const AttendanceSchema = new Schema<IAttendance>(
   {
-    teacherId: { type: String, required: true, index: true },
+    teacherId: { type: Schema.Types.ObjectId, ref: 'Teacher', required: true, index: true },
     studentId: { type: Schema.Types.ObjectId, ref: 'Student', required: true },
-    studentName: { type: String, required: true },
-    class: { type: String, required: true },
-    date: { type: String, required: true },
+    // revome the studentName because If student name changes → data becomes inconsistent
+    // remove because  Data inconsistency
+     class: { type: String, required: true, trim: true },
+    date: { type: Date, required: true },
     status: { type: String, enum: ['present', 'absent', 'late'], required: true },
   },
   { timestamps: true }
 )
 
+// existing uniqueness constraint
 AttendanceSchema.index({ studentId: 1, date: 1 }, { unique: true })
 
+// NEW: optimize teacher dashboard queries
+AttendanceSchema.index({ teacherId: 1, date: 1 })
+
+// NEW: optimize class-wise filtering
+AttendanceSchema.index({ teacherId: 1, class: 1 })
+
+// NEW: optimize status filtering (present/absent/late)
+AttendanceSchema.index({ teacherId: 1, status: 1 })
+
 export const Attendance = models.Attendance ?? model<IAttendance>('Attendance', AttendanceSchema)

models/Grade.ts

@@ -2,7 +2,7 @@ import mongoose, { Schema, model, models } from 'mongoose'
 
 export interface IGrade {
   _id: mongoose.Types.ObjectId
-  teacherId: string
+  teacherId: mongoose.Types.ObjectId
   studentId: mongoose.Types.ObjectId
   studentName: string
   subject: string
@@ -16,18 +16,22 @@ export interface IGrade {
 
 const GradeSchema = new Schema<IGrade>(
   {
-    teacherId: { type: String, required: true, index: true },
+    teacherId: { type: Schema.Types.ObjectId, ref: "Teacher", required: true, index: true },
     studentId: { type: Schema.Types.ObjectId, ref: "Student", required: true },
     studentName: { type: String, required: true },
-    subject: { type: String, required: true },
+    subject: { type: String,
+      enum: ['Mathematics', 'Data Structures', 'Operating Systems', 'DBMS', 'Computer Networks'],
+      required: true,},
     marks: {
       type: Number,
       required: true,
       min: 0,
     },
     maxMarks: { type: Number, default: 100, min: 1 },
     grade: { type: String, default: "" },
-    term: { type: String, default: "Term 1" },
+    term: {   type: String,
+      enum: ["Term 1", "Term 2"],
+      default: "Term 1", },
   },
   { timestamps: true },
 );