@studious-lms/server 1.2.45 → 1.2.47

package/src/routers/_app.ts

@@ -16,6 +16,7 @@ import { notificationRouter } from "./notifications.js";
 import { conversationRouter } from "./conversation.js";
 import { messageRouter } from "./message.js";
 import { labChatRouter } from "./labChat.js";
+import { newtonChatRouter } from "./newtonChat.js";
 import { marketingRouter } from "./marketing.js";
 import { worksheetRouter } from "./worksheet.js";
 import { commentRouter } from "./comment.js";
@@ -36,6 +37,7 @@ export const appRouter = createTRPCRouter({
   conversation: conversationRouter,
   message: messageRouter,
   labChat: labChatRouter,
+  newtonChat: newtonChatRouter,
   marketing: marketingRouter,
   worksheet: worksheetRouter,
   comment: commentRouter,

package/src/routers/agenda.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { prisma } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
-import { addDays, startOfDay, endOfDay } from "date-fns";
+import { addDays, addMonths, subMonths, startOfDay, endOfDay } from "date-fns";
 
 export const agendaRouter = createTRPCRouter({
   get: protectedProcedure
@@ -17,8 +17,11 @@ export const agendaRouter = createTRPCRouter({
         });
       }
 
-      const weekStart = startOfDay(new Date(input.weekStart));
-      const weekEnd = endOfDay(addDays(weekStart, 6));
+      // Expand query range to 6 months (3 months before and after the reference date)
+      // to allow calendar navigation and ensure newly created events are visible
+      const referenceDate = new Date(input.weekStart);
+      const rangeStart = startOfDay(subMonths(referenceDate, 3));
+      const rangeEnd = endOfDay(addMonths(referenceDate, 3));
 
       const [personalEvents, classEvents] = await Promise.all([
         // Get personal events
@@ -26,8 +29,8 @@ export const agendaRouter = createTRPCRouter({
           where: {
             userId: ctx.user.id,
             startTime: {
-              gte: weekStart,
-              lte: weekEnd,
+              gte: rangeStart,
+              lte: rangeEnd,
             },
             class: {
               is: null,
@@ -59,8 +62,8 @@ export const agendaRouter = createTRPCRouter({
               ],
             },
             startTime: {
-              gte: weekStart,
-              lte: weekEnd,
+              gte: rangeStart,
+              lte: rangeEnd,
             },
           },
           include: {

package/src/routers/announcement.ts

@@ -206,9 +206,10 @@ export const announcementRouter = createTRPCRouter({
             };
         }),
 
-    update: protectedProcedure
+    update: protectedTeacherProcedure
         .input(z.object({
             id: z.string(),
+            classId: z.string(),
             data: z.object({
                 remarks: z.string().min(1, "Remarks cannot be empty").optional(),
                 files: z.array(directFileSchema).optional(),
@@ -339,9 +340,10 @@ export const announcementRouter = createTRPCRouter({
             };
         }),
 
-    delete: protectedProcedure
+    delete: protectedTeacherProcedure
         .input(z.object({
             id: z.string(),
+            classId: z.string(),
         }))
         .mutation(async ({ ctx, input }) => {
             if (!ctx.user) {

package/src/routers/assignment.ts

@@ -6,6 +6,7 @@ import { createDirectUploadFiles, type DirectUploadFile, confirmDirectUpload, up
 import { deleteFile } from "../lib/googleCloudStorage.js";
 import { sendNotifications } from "../lib/notificationHandler.js";
 import { logger } from "../utils/logger.js";
+import { gradeWorksheetPipeline } from "../server/pipelines/gradeWorksheet.js";
 
 // DEPRECATED: This schema is no longer used - files are uploaded directly to GCS
 // Use directFileSchema instead
@@ -20,6 +21,7 @@ const directFileSchema = z.object({
 
 const createAssignmentSchema = z.object({
   classId: z.string(),
+  id: z.string().optional(),
   title: z.string(),
   instructions: z.string(),
   dueDate: z.string(),
@@ -173,11 +175,11 @@ async function getUnifiedList(tx: any, classId: string) {
 // Updated to batch updates to prevent timeouts with large lists
 async function normalizeUnifiedList(tx: any, classId: string, orderedItems: Array<{ id: string; type: 'section' | 'assignment' }>) {
   const BATCH_SIZE = 10; // Process 10 items at a time to avoid overwhelming the transaction
-  
+
   // Group items by type for more efficient updates
   const sections: Array<{ id: string; order: number }> = [];
   const assignments: Array<{ id: string; order: number }> = [];
-  
+
   orderedItems.forEach((item, index) => {
     const orderData = { id: item.id, order: index + 1 };
     if (item.type === 'section') {
@@ -186,7 +188,7 @@ async function normalizeUnifiedList(tx: any, classId: string, orderedItems: Arra
       assignments.push(orderData);
     }
   });
-  
+
   // Process updates in batches
   const processBatch = async (items: Array<{ id: string; order: number }>, type: 'section' | 'assignment') => {
     for (let i = 0; i < items.length; i += BATCH_SIZE) {
@@ -202,7 +204,7 @@ async function normalizeUnifiedList(tx: any, classId: string, orderedItems: Arra
       );
     }
   };
-  
+
   // Process sections and assignments sequentially to avoid transaction overload
   await processBatch(sections, 'section');
   await processBatch(assignments, 'assignment');
@@ -318,7 +320,21 @@ export const assignmentRouter = createTRPCRouter({
       return updated;
     }),
 
-    move: protectedTeacherProcedure
+  exists: protectedClassMemberProcedure
+    .input(z.object({
+      id: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({ code: 'UNAUTHORIZED', message: 'User must be authenticated' });
+      }
+      const assignment = await prisma.assignment.findUnique({
+        where: { id: input.id },
+      });
+      
+      return assignment ? true : false;
+    }),
+  move: protectedTeacherProcedure
     .input(z.object({
       id: z.string(),
       classId: z.string(),
@@ -354,10 +370,10 @@ export const assignmentRouter = createTRPCRouter({
       return updated;
     }),
 
-  create: protectedProcedure
+  create: protectedTeacherProcedure
     .input(createAssignmentSchema)
     .mutation(async ({ ctx, input }) => {
-      const { classId, title, instructions, dueDate, files, existingFileIds, aiPolicyLevel, acceptFiles, acceptExtendedResponse, acceptWorksheet, worksheetIds, gradeWithAI, studentIds, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId, inProgress } = input;
+      const { classId, id, title, instructions, dueDate, files, existingFileIds, aiPolicyLevel, acceptFiles, acceptExtendedResponse, acceptWorksheet, worksheetIds, gradeWithAI, studentIds, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId, inProgress } = input;
 
       if (!ctx.user) {
         throw new TRPCError({
@@ -401,16 +417,14 @@ export const assignmentRouter = createTRPCRouter({
         }, 0);
       }
 
-      console.log(studentIds);
-
       // Prepare submission data outside transaction
-      const submissionData = studentIds && studentIds.length > 0 
+      const submissionData = studentIds && studentIds.length > 0
         ? studentIds.map((studentId) => ({
-            student: { connect: { id: studentId } }
-          }))
+          student: { connect: { id: studentId } }
+        }))
         : classData.students.map((student) => ({
-            student: { connect: { id: student.id } }
-          }));
+          student: { connect: { id: student.id } }
+        }));
 
       const teacherId = ctx.user.id;
 
@@ -419,6 +433,7 @@ export const assignmentRouter = createTRPCRouter({
         // Create assignment with order 0 (will be at top)
         const created = await tx.assignment.create({
           data: {
+            ...(id && { id }),
             title,
             instructions,
             dueDate: new Date(dueDate),
@@ -516,7 +531,7 @@ export const assignmentRouter = createTRPCRouter({
             order: { increment: 1 }
           }
         });
-        
+
         await tx.section.updateMany({
           where: {
             classId: classId,
@@ -581,12 +596,12 @@ export const assignmentRouter = createTRPCRouter({
 
       // Execute file operations in parallel
       await Promise.all(fileOperations);
-      
+
       // Send notifications asynchronously (non-blocking)
       sendNotifications(classData.students.map(student => student.id), {
         title: `🔔 New assignment for ${classData.name}`,
         content:
-        `The assignment "${title}" has been created in ${classData.name}.\n
+          `The assignment "${title}" has been created in ${classData.name}.\n
         Due date: ${new Date(dueDate).toLocaleDateString()}.
         [Link to assignment](/class/${classId}/assignments/${assignment.id})`
       }).catch(error => {
@@ -595,7 +610,7 @@ export const assignmentRouter = createTRPCRouter({
 
       return assignment;
     }),
-  update: protectedProcedure
+  update: protectedTeacherProcedure
     .input(updateAssignmentSchema)
     .mutation(async ({ ctx, input }) => {
       const { id, title, instructions, dueDate, files, existingFileIds, worksheetIds, aiPolicyLevel, maxGrade, graded, weight, sectionId, type, inProgress, acceptFiles, acceptExtendedResponse, acceptWorksheet, gradeWithAI, studentIds } = input;
@@ -640,10 +655,10 @@ export const assignmentRouter = createTRPCRouter({
           },
         }),
         prisma.class.findFirst({
-          where: { 
-            assignments: { 
-              some: { id } 
-            } 
+          where: {
+            assignments: {
+              some: { id }
+            }
           },
           include: {
             students: {
@@ -661,13 +676,13 @@ export const assignmentRouter = createTRPCRouter({
       }
 
       // Prepare submission data outside transaction if needed
-      const submissionData = studentIds && studentIds.length > 0 
+      const submissionData = studentIds && studentIds.length > 0
         ? studentIds.map((studentId) => ({
-            student: { connect: { id: studentId } }
-          }))
+          student: { connect: { id: studentId } }
+        }))
         : classData?.students.map((student) => ({
-            student: { connect: { id: student.id } }
-          }));
+          student: { connect: { id: student.id } }
+        }));
 
       // Handle file deletion operations outside transaction
       const fileDeletionPromises: Promise<void>[] = [];
@@ -929,7 +944,7 @@ export const assignmentRouter = createTRPCRouter({
       };
     }),
 
-  get: protectedProcedure
+  get: protectedClassMemberProcedure
     .input(getAssignmentSchema)
     .query(async ({ ctx, input }) => {
       const { id, classId } = input;
@@ -1140,19 +1155,12 @@ export const assignmentRouter = createTRPCRouter({
       };
     }),
 
-  getSubmissionById: protectedTeacherProcedure
+  getSubmissionById: protectedClassMemberProcedure
     .input(z.object({
-      submissionId: z.string(),
       classId: z.string(),
+      submissionId: z.string(),
     }))
     .query(async ({ ctx, input }) => {
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
       const { submissionId, classId } = input;
 
       const submission = await prisma.submission.findFirst({
@@ -1161,11 +1169,22 @@ export const assignmentRouter = createTRPCRouter({
           assignment: {
             classId,
             class: {
-              teachers: {
-                some: {
-                  id: ctx.user.id
+              OR: [
+                {
+                  teachers: {
+                    some: {
+                      id: ctx.user?.id
+                    }
+                  }
+                },
+                {
+                  students: {
+                    some: {
+                      id: ctx.user?.id
+                    }
+                  }
                 }
-              }
+              ],
             }
           },
         },
@@ -1287,6 +1306,20 @@ export const assignmentRouter = createTRPCRouter({
 
       if (submit !== undefined) {
         // Toggle submission status
+        if (submission.assignment.acceptWorksheet && submission.assignment.gradeWithAI) {
+
+          // Grade the submission with AI
+          const worksheetResponses = await prisma.studentWorksheetResponse.findMany({
+            where: {
+              submissionId: submission.id,
+            },
+          });
+
+          for (const worksheetResponse of worksheetResponses) {
+            // Run it in the background, non-blocking
+            gradeWorksheetPipeline(worksheetResponse.id);
+          }
+        }
         return await prisma.submission.update({
           where: { id: submission.id },
           data: {

package/src/routers/attendance.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { createTRPCRouter, protectedClassMemberProcedure, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 
@@ -11,7 +11,7 @@ const attendanceSchema = z.object({
 });
 
 export const attendanceRouter = createTRPCRouter({
-  get: protectedProcedure
+  get: protectedClassMemberProcedure
     .input(z.object({
       classId: z.string(),
       eventId: z.string().optional(),

package/src/routers/auth.ts

@@ -4,8 +4,10 @@ import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 import { v4 as uuidv4 } from 'uuid';
 import { compare, hash } from "bcryptjs";
-import { transport } from "../utils/email.js";
+import { sendMail } from "../utils/email.js";
 import { prismaWrapper } from "../utils/prismaWrapper.js";
+import { env } from "../lib/config/env.js";
+import { logger } from "../utils/logger.js";
 
 const loginSchema = z.object({
   username: z.string(),
@@ -106,14 +108,18 @@ export const authRouter = createTRPCRouter({
         'creating verification token'
       );
 
-      // await transport.sendMail({
-      //   from: 'noreply@studious.sh',
-      //   to: user.email,
-      //   subject: 'Verify your email',
-      //   text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
-      // });
+      try {
+        await sendMail({
+        from: 'noreply@studious.sh',
+        to: user.email,
+        subject: 'Verify your email',
+          text: `Click the link to verify your email: ${env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+        });
+      } catch (err) {
+        logger.error('Failed to send verification email', { email: user.email, err });
+      }
 
-      console.log(`${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`)
+      // logger.info(`Password verification email sent to ${user.email} at ${env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`);
 
       return {
         user: {
@@ -280,12 +286,18 @@ export const authRouter = createTRPCRouter({
           },
         });
         
-        // await transport.sendMail({
-        //   from: 'noreply@studious.sh',
-        //   to: user.email,
-        //   subject: 'Verify your email',
-        //   text: `Click the link to verify your email: ${process.env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
-        // });
+        try {
+          await sendMail({
+          from: 'noreply@studious.sh',
+          to: user.email,
+            subject: 'Verify your email',
+            text: `Click the link to verify your email: ${env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`,
+          });
+        } catch (err) {
+          logger.error('Failed to send verification email', { email: user.email, err });
+        }
+
+        // logger.info(`Password verification email sent to ${user.email} at ${env.NEXT_PUBLIC_APP_URL}/verify/${verificationToken.id}`);
 
         return { success: true };
       }),
@@ -326,6 +338,123 @@ export const authRouter = createTRPCRouter({
           where: { id: token },
         });
 
+        return { success: true };
+      }),
+
+    requestPasswordReset: publicProcedure
+      .input(z.object({
+        email: z.string().email(),
+      }))
+      .mutation(async ({ input }) => {
+        const { email } = input;
+
+        const user = await prisma.user.findFirst({
+          where: { email },
+          select: {
+            id: true,
+            email: true,
+            username: true,
+          },
+        });
+
+        // Don't reveal if user exists or not for security
+        if (!user) {
+          return { success: true };
+        }
+
+        // Delete any existing password reset tokens for this user
+        // Only delete tokens that expire within 2 hours (likely password reset tokens)
+        const twoHoursFromNow = new Date(Date.now() + 1000 * 60 * 60 * 2);
+        await prisma.session.deleteMany({
+          where: { 
+            userId: user.id,
+            classId: null,
+            expiresAt: {
+              lte: twoHoursFromNow, // Only delete short-lived tokens (password reset tokens)
+            },
+          },
+        });
+
+        // Create a new password reset token (expires in 1 hour)
+        const resetToken = await prisma.session.create({
+          data: {
+            id: uuidv4(),
+            userId: user.id,
+            expiresAt: new Date(Date.now() + 1000 * 60 * 60), // 1 hour
+          },
+        });
+
+        // Send password reset email
+        try {
+          await sendMail({
+            from: 'noreply@studious.sh',
+            to: user.email,
+            subject: 'Reset your password',
+            text: `Click the link to reset your password: ${env.NEXT_PUBLIC_APP_URL}/reset-password/${resetToken.id}`,
+          });
+        } catch (err) {
+          logger.error('Failed to send password reset email', { email: user.email, err });
+        }
+
+        // logger.info(`Password reset email sent to ${user.email} at ${env.NEXT_PUBLIC_APP_URL}/reset-password/${resetToken.id}`);
+
+        return { success: true };
+      }),
+
+    resetPassword: publicProcedure
+      .input(z.object({
+        token: z.string(),
+        password: z.string().min(6, "Password must be at least 6 characters"),
+        confirmPassword: z.string(),
+      }).refine((data) => data.password === data.confirmPassword, {
+        message: "Passwords don't match",
+        path: ["confirmPassword"],
+      }))
+      .mutation(async ({ input }) => {
+        const { token, password } = input;
+
+        const session = await prisma.session.findUnique({
+          where: { id: token },
+          include: {
+            user: {
+              select: {
+                id: true,
+              },
+            },
+          },
+        });
+
+        if (!session || !session.userId) {
+          throw new TRPCError({
+            code: "NOT_FOUND",
+            message: "Invalid or expired reset token",
+          });
+        }
+
+        if (session.expiresAt && session.expiresAt < new Date()) {
+          // Clean up expired token
+          await prisma.session.delete({
+            where: { id: token },
+          });
+          throw new TRPCError({
+            code: "UNAUTHORIZED",
+            message: "Reset token has expired",
+          });
+        }
+
+        // Update the user's password
+        await prisma.user.update({
+          where: { id: session.userId },
+          data: {
+            password: await hash(password, 10),
+          },
+        });
+
+        // Clean up the reset token
+        await prisma.session.delete({
+          where: { id: token },
+        });
+
         return { success: true };
       }),
 }); 

package/src/routers/class.ts

@@ -465,6 +465,51 @@ export const classRouter = createTRPCRouter({
         removedUserId: userId,
       };
     }),
+  leaveClass: protectedProcedure
+    .input(z.object({
+      classId: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { classId } = input;
+      const userId = ctx.user?.id;
+
+      if (!userId) {
+        throw new TRPCError({
+          code: 'UNAUTHORIZED',
+          message: 'User not authenticated',
+        });
+      }
+
+      const classData = await prisma.class.findFirst({
+        where: {
+          id: classId,
+          students: {
+            some: { id: userId },
+          },
+        },
+      });
+
+      if (!classData) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Class not found or you are not a student in this class',
+        });
+      }
+
+      await prisma.class.update({
+        where: { id: classId },
+        data: {
+          students: {
+            disconnect: { id: userId },
+          },
+        },
+      });
+
+      return {
+        success: true,
+        leftClassId: classId,
+      };
+    }),
   join: protectedProcedure
     .input(z.object({
       classCode: z.string(),
@@ -472,9 +517,13 @@ export const classRouter = createTRPCRouter({
     .mutation(async ({ ctx, input }) => {
       const { classCode } = input;
 
+      // Case-insensitive search for invite code
       const session = await prisma.session.findFirst({
         where: {
-          id: classCode,
+          id: {
+            equals: classCode,
+            mode: 'insensitive',
+          },
         },
       });
 
@@ -676,7 +725,7 @@ export const classRouter = createTRPCRouter({
 
         return events;
       }),
-    listMarkSchemes: protectedTeacherProcedure
+    listMarkSchemes: protectedClassMemberProcedure
       .input(z.object({
         classId: z.string(),
       }))
@@ -755,7 +804,7 @@ export const classRouter = createTRPCRouter({
 
         return markScheme;
       }),
-    listGradingBoundaries: protectedTeacherProcedure
+    listGradingBoundaries: protectedClassMemberProcedure
       .input(z.object({
         classId: z.string(),
       }))