@studious-lms/server 1.2.45 → 1.2.47

package/src/routers/newtonChat.ts

@@ -0,0 +1,299 @@
+import { z } from 'zod';
+import { createTRPCRouter, protectedProcedure } from '../trpc.js';
+import { prisma } from '../lib/prisma.js';
+import { pusher } from '../lib/pusher.js';
+import { TRPCError } from '@trpc/server';
+import { logger } from '../utils/logger.js';
+import { isAIUser } from '../utils/aiUser.js';
+import { generateAndSendNewtonIntroduction, generateAndSendNewtonResponse } from '../server/pipelines/aiNewtonChat.js';
+
+export const newtonChatRouter = createTRPCRouter({
+  getTutorConversation: protectedProcedure
+    .input(
+      z.object({
+        assignmentId: z.string(),
+        classId: z.string(),
+      })
+    )
+    .query(async ({ input, ctx }) => {
+      const userId = ctx.user!.id;
+      const { assignmentId, classId } = input;
+
+      // Verify user is a student in the class
+      const classMembership = await prisma.class.findFirst({
+        where: {
+          id: classId,
+          students: {
+            some: {
+              id: userId,
+            },
+          },
+        },
+      });
+
+      if (!classMembership) {
+        throw new TRPCError({
+          code: 'FORBIDDEN',
+          message: 'Not a student in this class',
+        });
+      }
+
+      // Find or create submission for this student and assignment
+      const submission = await prisma.submission.findFirst({
+        where: {
+          assignmentId,
+          studentId: userId,
+        },
+      });
+
+      if (!submission) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Submission not found. Please create a submission first.',
+        });
+      }
+
+      // Find the latest NewtonChat for this submission, or create a new one
+      const result = await prisma.$transaction(async (tx) => {
+        // Get the latest NewtonChat for this submission
+        const existingNewtonChat = await tx.newtonChat.findFirst({
+          where: {
+            submissionId: submission.id,
+          },
+          include: {
+            conversation: {
+              include: {
+                members: {
+                  where: {
+                    userId,
+                  },
+                },
+              },
+            },
+          },
+          orderBy: {
+            createdAt: 'desc',
+          },
+        });
+
+        // If exists and user is already a member, return it
+        if (existingNewtonChat && existingNewtonChat.conversation.members.length > 0) {
+          return existingNewtonChat;
+        }
+
+        // If exists but user is not a member, add them
+        if (existingNewtonChat) {
+          await tx.conversationMember.create({
+            data: {
+              userId,
+              conversationId: existingNewtonChat.conversationId,
+              role: 'MEMBER',
+            },
+          });
+
+          return existingNewtonChat;
+        }
+
+        // Create new NewtonChat with associated conversation
+        const conversation = await tx.conversation.create({
+          data: {
+            type: 'DM',
+            name: 'Session with Newton Tutor',
+            displayInChat: false, // Newton chats don't show in regular chat list
+          },
+        });
+
+        // Add student to the conversation
+        await tx.conversationMember.create({
+          data: {
+            userId,
+            conversationId: conversation.id,
+            role: 'MEMBER',
+          },
+        });
+
+        // Create the NewtonChat
+        const newtonChat = await tx.newtonChat.create({
+          data: {
+            submissionId: submission.id,
+            conversationId: conversation.id,
+            title: 'Session with Newton Tutor',
+          },
+        });
+
+        return newtonChat;
+      });
+
+      // Generate AI introduction message in parallel (don't await - fire and forget)
+      generateAndSendNewtonIntroduction(
+        result.id,
+        result.conversationId,
+        submission.id
+      ).catch(error => {
+        logger.error('Failed to generate AI introduction:', { error, newtonChatId: result.id });
+      });
+
+      return {
+        conversationId: result.conversationId,
+        newtonChatId: result.id,
+      };
+    }),
+
+  postToNewtonChat: protectedProcedure
+    .input(
+      z.object({
+        newtonChatId: z.string(),
+        content: z.string().min(1).max(4000),
+        mentionedUserIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(async ({ input, ctx }) => {
+      const userId = ctx.user!.id;
+      const { newtonChatId, content, mentionedUserIds = [] } = input;
+
+      // Get newton chat and verify user is a member
+      const newtonChat = await prisma.newtonChat.findFirst({
+        where: {
+          id: newtonChatId,
+          conversation: {
+            members: {
+              some: {
+                userId,
+              },
+            },
+          },
+        },
+        include: {
+          conversation: {
+            select: {
+              id: true,
+            },
+          },
+          submission: {
+            include: {
+              assignment: {
+                select: {
+                  id: true,
+                  title: true,
+                  instructions: true,
+                  class: {
+                    select: {
+                      subject: true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      });
+
+      if (!newtonChat) {
+        throw new TRPCError({
+          code: 'FORBIDDEN',
+          message: 'Newton chat not found or access denied',
+        });
+      }
+
+      // Verify mentioned users are members of the conversation
+      if (mentionedUserIds.length > 0) {
+        const mentionedMemberships = await prisma.conversationMember.findMany({
+          where: {
+            conversationId: newtonChat.conversationId,
+            userId: { in: mentionedUserIds },
+          },
+        });
+
+        if (mentionedMemberships.length !== mentionedUserIds.length) {
+          throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: 'Some mentioned users are not members of this conversation',
+          });
+        }
+      }
+
+      // Create message and mentions
+      const result = await prisma.$transaction(async (tx) => {
+        const message = await tx.message.create({
+          data: {
+            content,
+            senderId: userId,
+            conversationId: newtonChat.conversationId,
+          },
+          include: {
+            sender: {
+              select: {
+                id: true,
+                username: true,
+                profile: {
+                  select: {
+                    displayName: true,
+                    profilePicture: true,
+                  },
+                },
+              },
+            },
+          },
+        });
+
+        // Create mentions
+        if (mentionedUserIds.length > 0) {
+          await tx.mention.createMany({
+            data: mentionedUserIds.map((mentionedUserId) => ({
+              messageId: message.id,
+              userId: mentionedUserId,
+            })),
+          });
+        }
+
+        // Update newton chat timestamp
+        await tx.newtonChat.update({
+          where: { id: newtonChatId },
+          data: { updatedAt: new Date() },
+        });
+
+        return message;
+      });
+
+      // Broadcast to Pusher channel (same format as regular chat)
+      try {
+        await pusher.trigger(`conversation-${newtonChat.conversationId}`, 'new-message', {
+          id: result.id,
+          content: result.content,
+          senderId: result.senderId,
+          conversationId: result.conversationId,
+          createdAt: result.createdAt,
+          sender: result.sender,
+          mentionedUserIds,
+        });
+      } catch (error) {
+        console.error('Failed to broadcast newton chat message:', error);
+        // Don't fail the request if Pusher fails
+      }
+
+      // Generate AI response in parallel (don't await - fire and forget)
+      if (!isAIUser(userId)) {
+        // Run AI response generation in background
+        generateAndSendNewtonResponse(
+          newtonChatId,
+          content,
+          newtonChat.conversationId,
+          newtonChat.submission
+        ).catch(error => {
+          logger.error('Failed to generate AI response:', { error });
+        });
+      }
+
+      return {
+        id: result.id,
+        content: result.content,
+        senderId: result.senderId,
+        conversationId: result.conversationId,
+        createdAt: result.createdAt,
+        sender: result.sender,
+        mentionedUserIds,
+      };
+    }),
+});
+
+

package/src/routers/section.ts

@@ -1,10 +1,11 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { createTRPCRouter, protectedClassMemberProcedure, protectedProcedure, protectedTeacherProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 
 const createSectionSchema = z.object({
   classId: z.string(),
+  id: z.string().optional(),
   name: z.string(),
   color: z.string().optional(),
 });
@@ -22,7 +23,25 @@ const deleteSectionSchema = z.object({
 });
 
 export const sectionRouter = createTRPCRouter({
-  create: protectedProcedure
+  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 section = await prisma.section.findUnique({
+        where: { id: input.id },
+      });
+
+      return section ? true : false;
+    }),
+  create: protectedTeacherProcedure
     .input(createSectionSchema)
     .mutation(async ({ ctx, input }) => {
       if (!ctx.user) {
@@ -53,6 +72,7 @@ export const sectionRouter = createTRPCRouter({
 
       const section = await prisma.section.create({
         data: {
+          ...(input.id && { id: input.id }),
           name: input.name,
           order: 0,
           class: {
@@ -97,7 +117,7 @@ export const sectionRouter = createTRPCRouter({
       return section;
     }),
 
-  reorder: protectedProcedure
+  reorder: protectedTeacherProcedure
     .input(z.object({
       classId: z.string(),
       movedId: z.string(), // Section ID
@@ -195,7 +215,7 @@ export const sectionRouter = createTRPCRouter({
       return result;
     }),
 
-  update: protectedProcedure
+  update: protectedTeacherProcedure
     .input(updateSectionSchema)
     .mutation(async ({ ctx, input }) => {
       if (!ctx.user) {
@@ -237,7 +257,7 @@ export const sectionRouter = createTRPCRouter({
       return section;
     }),
 
-  reOrder: protectedProcedure
+  reOrder: protectedTeacherProcedure
     .input(z.object({
       id: z.string(),
       classId: z.string(),
@@ -308,7 +328,7 @@ export const sectionRouter = createTRPCRouter({
       return { id: input.id };
     }),
 
-  delete: protectedProcedure
+  delete: protectedTeacherProcedure
     .input(deleteSectionSchema)
     .mutation(async ({ ctx, input }) => {
       if (!ctx.user) {

package/src/routers/user.ts

@@ -6,6 +6,7 @@ import { createDirectUploadFiles, type DirectUploadFile } from "../lib/fileUploa
 import { getSignedUrl } from "../lib/googleCloudStorage.js";
 import { logger } from "../utils/logger.js";
 import { bucket } from "../lib/googleCloudStorage.js";
+import { env } from "../lib/config/env.js";
 
 // Helper function to convert file path to backend proxy URL
 function getFileUrl(filePath: string | null): string | null {
@@ -17,7 +18,7 @@ function getFileUrl(filePath: string | null): string | null {
   }
   
   // Convert GCS path to full backend proxy URL
-  const backendUrl = process.env.BACKEND_URL || 'http://localhost:3001';
+  const backendUrl = env.BACKEND_URL || 'http://localhost:3001';
   return `${backendUrl}/api/files/${encodeURIComponent(filePath)}`;
 }
 
@@ -229,7 +230,7 @@ export const userRouter = createTRPCRouter({
         const filePath = `users/${ctx.user.id}/profile/${uniqueFilename}`;
 
         // Generate backend proxy upload URL instead of direct GCS signed URL
-        const backendUrl = process.env.BACKEND_URL || 'http://localhost:3001';
+        const backendUrl = env.BACKEND_URL || 'http://localhost:3001';
         const uploadUrl = `${backendUrl}/api/upload/${encodeURIComponent(filePath)}`;
 
         logger.info('Generated upload URL', {

package/src/routers/worksheet.ts

@@ -1,8 +1,8 @@
 import { TRPCError } from "@trpc/server";
-import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { createTRPCRouter, protectedClassMemberProcedure, protectedProcedure } from "../trpc.js";
 import { z } from "zod";
 import { prisma } from "../lib/prisma.js";
-import { WorksheetQuestionType } from "@prisma/client";
+import { GenerationStatus, WorksheetQuestionType } from "@prisma/client";
 import { commentSelect } from "./comment.js";
 
 type MCQOptions = {
@@ -38,6 +38,22 @@ export const worksheetRouter = createTRPCRouter({
       return worksheet;
     }),
 
+  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 worksheet = await prisma.worksheet.findUnique({
+        where: { id: input.id },
+      });
+
+      return worksheet ? true : false;
+    }),
+
   // List all worksheets for a class
   listWorksheets: protectedProcedure
     .input(z.object({
@@ -372,6 +388,7 @@ export const worksheetRouter = createTRPCRouter({
           data: { response, 
             ...(isMarkableByAlgo && { isCorrect: response === correctAnswer }),
             ...(isMarkableByAlgo && { points: response === correctAnswer ? marksAwardedIfCorrect : 0 }),
+            status: GenerationStatus.NOT_STARTED,
            },
         });
       } else {
@@ -398,52 +415,23 @@ export const worksheetRouter = createTRPCRouter({
 
       return updatedWorksheetResponse;
     }),
-    submitWorksheet: protectedProcedure
+  cancelAutoGrading: protectedProcedure
     .input(z.object({
       worksheetResponseId: z.string(),
+      questionId: z.string(),
     }))
     .mutation(async ({ ctx, input }) => {
-      const { worksheetResponseId } = input;
+      const { worksheetResponseId, questionId } = input;
 
-      const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
-        where: { id: worksheetResponseId },
-        include: {
-          worksheet: {
-            include: {
-              questions: true,
-            },
-          },
-          responses: true,
-        },
-      });
-
-      if (!worksheetResponse) {
-        throw new TRPCError({ code: 'NOT_FOUND', message: 'Worksheet response not found' });
-      }
-
-      if (worksheetResponse.submitted) {
-        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Worksheet already submitted' });
-      }
-
-      // Mark worksheet as submitted
-      const submittedWorksheet = await prisma.studentWorksheetResponse.update({
-        where: { id: worksheetResponseId },
+      const updatedQuestion = await prisma.studentQuestionProgress.update({
+        where: { id: questionId, studentWorksheetResponseId: worksheetResponseId },
         data: {
-          submitted: true,
-          submittedAt: new Date(),
-        },
-        include: {
-          responses: true,
+          status: GenerationStatus.CANCELLED,
         },
       });
 
-      // TODO: Implement AI grading here
-      // For now, we'll just mark all answers as pending review
-      // You could integrate with an AI service to auto-grade certain question types
-      
-      return submittedWorksheet;
+      return updatedQuestion;
     }),
-
   // Grade a student's answer
   gradeAnswer: protectedProcedure
     .input(z.object({