@studious-lms/server 1.2.34 → 1.2.35

package/dist/routers/worksheet.d.ts

@@ -38,7 +38,7 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
                 order: number | null;
                 markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
                 updatedAt: Date;
-                points: number | null;
+                points: number;
                 question: string;
                 worksheetId: string;
                 answer: string;
@@ -128,7 +128,7 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
             order: number | null;
             markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
             updatedAt: Date;
-            points: number | null;
+            points: number;
             question: string;
             worksheetId: string;
             answer: string;
@@ -166,7 +166,7 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
             order: number | null;
             markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
             updatedAt: Date;
-            points: number | null;
+            points: number;
             question: string;
             worksheetId: string;
             answer: string;
@@ -186,7 +186,7 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
             order: number | null;
             markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
             updatedAt: Date;
-            points: number | null;
+            points: number;
             question: string;
             worksheetId: string;
             answer: string;
@@ -204,11 +204,13 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
                 feedback: string | null;
                 studentId: string;
                 createdAt: Date;
-                updatedAt: Date;
+                updatedAt: Date | null;
+                points: number;
                 questionId: string;
                 response: string;
-                isCorrect: boolean;
                 studentWorksheetResponseId: string | null;
+                isCorrect: boolean;
+                markschemeState: import("@prisma/client/runtime/library.js").JsonValue | null;
             }[];
         } & {
             id: string;
@@ -234,11 +236,13 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
                 feedback: string | null;
                 studentId: string;
                 createdAt: Date;
-                updatedAt: Date;
+                updatedAt: Date | null;
+                points: number;
                 questionId: string;
                 response: string;
-                isCorrect: boolean;
                 studentWorksheetResponseId: string | null;
+                isCorrect: boolean;
+                markschemeState: import("@prisma/client/runtime/library.js").JsonValue | null;
             }[];
         } & {
             id: string;
@@ -262,55 +266,14 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
                 feedback: string | null;
                 studentId: string;
                 createdAt: Date;
-                updatedAt: Date;
+                updatedAt: Date | null;
+                points: number;
                 questionId: string;
                 response: string;
-                isCorrect: boolean;
                 studentWorksheetResponseId: string | null;
-            }[];
-        } & {
-            id: string;
-            submissionId: string | null;
-            studentId: string;
-            createdAt: Date;
-            updatedAt: Date;
-            submittedAt: Date | null;
-            submitted: boolean;
-            worksheetId: string;
-        };
-        meta: object;
-    }>;
-    getOrCreateWorksheetResponse: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            studentId: string;
-            worksheetId: string;
-        };
-        output: {
-            responses: ({
-                question: {
-                    type: import(".prisma/client").$Enums.WorksheetQuestionType;
-                    id: string;
-                    options: import("@prisma/client/runtime/library.js").JsonValue | null;
-                    createdAt: Date;
-                    order: number | null;
-                    markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
-                    updatedAt: Date;
-                    points: number | null;
-                    question: string;
-                    worksheetId: string;
-                    answer: string;
-                };
-            } & {
-                id: string;
-                feedback: string | null;
-                studentId: string;
-                createdAt: Date;
-                updatedAt: Date;
-                questionId: string;
-                response: string;
                 isCorrect: boolean;
-                studentWorksheetResponseId: string | null;
-            })[];
+                markschemeState: import("@prisma/client/runtime/library.js").JsonValue | null;
+            }[];
         } & {
             id: string;
             submissionId: string | null;
@@ -323,72 +286,34 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
-    getWorksheetResponse: import("@trpc/server").TRPCQueryProcedure<{
+    gradeAnswer: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            worksheetId: string;
+            questionId: string;
+            studentWorksheetResponseId: string;
+            isCorrect: boolean;
+            feedback?: string | undefined;
+            points?: number | undefined;
+            response?: string | undefined;
+            responseId?: string | undefined;
+            markschemeState?: any;
         };
-        output: ({
-            student: {
-                id: string;
-                username: string;
-                profile: {
-                    displayName: string | null;
-                    profilePicture: string | null;
-                } | null;
-            };
-            responses: ({
-                question: {
-                    type: import(".prisma/client").$Enums.WorksheetQuestionType;
-                    id: string;
-                    options: import("@prisma/client/runtime/library.js").JsonValue | null;
-                    createdAt: Date;
-                    order: number | null;
-                    markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
-                    updatedAt: Date;
-                    points: number | null;
-                    question: string;
-                    worksheetId: string;
-                    answer: string;
-                };
-            } & {
-                id: string;
-                feedback: string | null;
-                studentId: string;
-                createdAt: Date;
-                updatedAt: Date;
-                questionId: string;
-                response: string;
-                isCorrect: boolean;
-                studentWorksheetResponseId: string | null;
-            })[];
-        } & {
-            id: string;
-            submissionId: string | null;
-            studentId: string;
-            createdAt: Date;
-            updatedAt: Date;
-            submittedAt: Date | null;
-            submitted: boolean;
-            worksheetId: string;
-        }) | null;
+        output: any;
         meta: object;
     }>;
-    gradeAnswer: import("@trpc/server").TRPCMutationProcedure<{
+    addComment: import("@trpc/server").TRPCMutationProcedure<{
         input: {
+            comment: string;
             responseId: string;
-            isCorrect: boolean;
-            feedback?: string | undefined;
         };
         output: {
             id: string;
-            feedback: string | null;
-            studentId: string;
+            content: string;
             createdAt: Date;
-            updatedAt: Date;
-            questionId: string;
-            response: string;
-            isCorrect: boolean;
-            studentWorksheetResponseId: string | null;
+            modifiedAt: Date | null;
+            announcementId: string | null;
+            parentCommentId: string | null;
+            authorId: string;
+            studentQuestionProgressId: string | null;
         };
         meta: object;
     }>;

package/dist/routers/worksheet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worksheet.d.ts","sourceRoot":"","sources":["../../src/routers/worksheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA6KA,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0UhC,CAAC"}
+{"version":3,"file":"worksheet.d.ts","sourceRoot":"","sources":["../../src/routers/worksheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA8KA,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4UhC,CAAC"}

package/dist/routers/worksheet.js

@@ -15,6 +15,7 @@ export const worksheetRouter = createTRPCRouter({
             include: {
                 questions: {
                     orderBy: { createdAt: 'asc' },
+                    // select: { id: true, type: true, question: true, answer: true, points: true },
                 },
                 class: true,
             },
@@ -344,95 +345,99 @@ export const worksheetRouter = createTRPCRouter({
         // You could integrate with an AI service to auto-grade certain question types
         return submittedWorksheet;
     }),
-    // Get or create a student's worksheet response
-    getOrCreateWorksheetResponse: protectedProcedure
+    // Grade a student's answer
+    gradeAnswer: protectedProcedure
         .input(z.object({
-        worksheetId: z.string(),
-        studentId: z.string(),
+        questionId: z.string(),
+        responseId: z.string().optional(), // StudentQuestionProgress ID (optional for upsert)
+        studentWorksheetResponseId: z.string(), // Required for linking to worksheet response
+        response: z.string().optional(), // The actual response text (needed if creating new)
+        isCorrect: z.boolean(),
+        feedback: z.string().optional(),
+        markschemeState: z.any().optional(),
+        points: z.number().optional(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { worksheetId, studentId } = input;
-        // Try to find existing response
-        let worksheetResponse = await prisma.studentWorksheetResponse.findFirst({
-            where: {
-                worksheetId,
-                studentId,
-                submitted: false, // Only get unsubmitted responses
-            },
-            include: {
-                responses: {
-                    include: {
-                        question: true,
-                    },
-                },
-            },
-        });
-        // Create new response if none exists
-        if (!worksheetResponse) {
-            worksheetResponse = await prisma.studentWorksheetResponse.create({
+        const { responseId, questionId, studentWorksheetResponseId, response, isCorrect, feedback, markschemeState, points } = input;
+        let gradedResponse;
+        if (responseId) {
+            // Update existing progress by ID
+            gradedResponse = await prisma.studentQuestionProgress.update({
+                where: { id: responseId },
                 data: {
-                    worksheetId,
-                    studentId,
-                },
-                include: {
-                    responses: {
-                        include: {
-                            question: true,
-                        },
-                    },
+                    isCorrect,
+                    ...(feedback !== undefined && { feedback }),
+                    ...(markschemeState !== undefined && { markschemeState }),
+                    ...(points !== undefined && { points }),
                 },
             });
         }
-        return worksheetResponse;
-    }),
-    // Get all student responses for a worksheet (teacher view)
-    getWorksheetResponse: protectedProcedure
-        .input(z.object({
-        worksheetId: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const { worksheetId } = input;
-        const responses = await prisma.studentWorksheetResponse.findFirst({
-            where: { worksheetId },
-            include: {
-                student: {
-                    select: {
-                        id: true,
-                        username: true,
-                        profile: {
-                            select: {
-                                displayName: true,
-                                profilePicture: true,
-                            },
-                        },
-                    },
+        else {
+            // Get the studentId from the worksheet response
+            const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+                where: { id: studentWorksheetResponseId },
+                select: { studentId: true },
+            });
+            if (!worksheetResponse) {
+                throw new TRPCError({
+                    code: 'NOT_FOUND',
+                    message: 'Student worksheet response not found',
+                });
+            }
+            const { studentId } = worksheetResponse;
+            // Upsert - find or create the progress record
+            const existing = await prisma.studentQuestionProgress.findFirst({
+                where: {
+                    studentId,
+                    questionId,
+                    studentWorksheetResponseId,
                 },
-                responses: {
-                    include: {
-                        question: true,
+            });
+            if (existing) {
+                // Update existing
+                gradedResponse = await prisma.studentQuestionProgress.update({
+                    where: { id: existing.id },
+                    data: {
+                        isCorrect,
+                        ...(response !== undefined && { response }),
+                        ...(feedback !== undefined && { feedback }),
+                        ...(markschemeState !== undefined && { markschemeState }),
+                        ...(points !== undefined && { points }),
                     },
-                },
-            },
-            orderBy: { submittedAt: 'desc' },
-        });
-        return responses;
+                });
+            }
+            else {
+                // Create new
+                gradedResponse = await prisma.studentQuestionProgress.create({
+                    data: {
+                        studentId,
+                        questionId,
+                        studentWorksheetResponseId,
+                        response: response || '',
+                        isCorrect,
+                        ...(feedback !== undefined && { feedback }),
+                        ...(markschemeState !== undefined && { markschemeState }),
+                        ...(points !== undefined && { points: points || 0 }),
+                    },
+                });
+            }
+        }
+        return gradedResponse;
     }),
-    // Grade a student's answer
-    gradeAnswer: protectedProcedure
+    addComment: protectedProcedure
         .input(z.object({
-        responseId: z.string(), // StudentQuestionProgress ID
-        isCorrect: z.boolean(),
-        feedback: z.string().optional(),
+        responseId: z.string(),
+        comment: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { responseId, isCorrect, feedback } = input;
-        const gradedResponse = await prisma.studentQuestionProgress.update({
-            where: { id: responseId },
+        const { responseId, comment } = input;
+        const newComment = await prisma.comment.create({
             data: {
-                isCorrect,
-                ...(feedback !== undefined && { feedback }),
+                studentQuestionProgressId: responseId,
+                content: comment,
+                authorId: ctx.user.id,
             },
         });
-        return gradedResponse;
+        return newComment;
     }),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.2.34",
+  "version": "1.2.35",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",

package/prisma/schema.prisma

@@ -301,14 +301,16 @@ model Comment {
   content       String
   author        User @relation(fields: [authorId], references: [id], onDelete: Cascade)
   authorId      String
-  announcement  Announcement @relation(fields: [announcementId], references: [id], onDelete: Cascade)
-  announcementId String
+  announcement  Announcement? @relation(fields: [announcementId], references: [id], onDelete: Cascade)
+  announcementId String?
   parentComment Comment? @relation("CommentReplies", fields: [parentCommentId], references: [id], onDelete: Cascade)
   parentCommentId String?
   replies       Comment[] @relation("CommentReplies")
   reactions     Reaction[]
   createdAt     DateTime @default(now())
   modifiedAt    DateTime? @updatedAt
+  studentQuestionProgress StudentQuestionProgress? @relation("StudentQuestionProgressComments", fields: [studentQuestionProgressId], references: [id], onDelete: Cascade)
+  studentQuestionProgressId String?
 }
 
 model Reaction {
@@ -517,7 +519,7 @@ model WorksheetQuestion {
   answer String
   options Json?  @default("{}")
   markScheme Json?  @default("{}")
-  points Int? @default(0)
+  points Int @default(0)
   order Int? @default(0)
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
@@ -547,11 +549,16 @@ model StudentQuestionProgress {
   question WorksheetQuestion @relation(fields: [questionId], references: [id], onDelete: Cascade)
   response String
   isCorrect Boolean @default(false)
+  markschemeState Json? @default("{}")
+  points Int @default(0)
+  comments Comment[] @relation("StudentQuestionProgressComments")
   feedback String?
   createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
+  updatedAt DateTime? @updatedAt
   studentWorksheetResponseId String?
   studentWorksheetResponse StudentWorksheetResponse? @relation(fields: [studentWorksheetResponseId], references: [id], onDelete: Cascade)
+  
+  @@index([studentId, questionId])
 }
 
 model SchoolDevelopementProgram {

package/src/routers/_app.ts

@@ -18,6 +18,7 @@ import { messageRouter } from "./message.js";
 import { labChatRouter } from "./labChat.js";
 import { marketingRouter } from "./marketing.js";
 import { worksheetRouter } from "./worksheet.js";
+import { commentRouter } from "./comment.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -37,6 +38,7 @@ export const appRouter = createTRPCRouter({
   labChat: labChatRouter,
   marketing: marketingRouter,
   worksheet: worksheetRouter,
+  comment: commentRouter,
 }); 
 
 // Export type router type definition

package/src/routers/announcement.ts

@@ -667,7 +667,7 @@ export const announcementRouter = createTRPCRouter({
             // Only the author or a class teacher can delete comments
             const userId = ctx.user.id;
             const isAuthor = comment.authorId === userId;
-            const isClassTeacher = comment.announcement.class.teachers.some(
+            const isClassTeacher = comment.announcement!.class.teachers.some(
                 (teacher) => teacher.id === userId
             );
 
@@ -858,7 +858,7 @@ export const announcementRouter = createTRPCRouter({
                     });
                 }
 
-                if (comment.announcement.classId !== input.classId) {
+                if (comment.announcement!.classId !== input.classId) {
                     throw new TRPCError({
                         code: "FORBIDDEN",
                         message: "Comment does not belong to this class",
@@ -1078,7 +1078,7 @@ export const announcementRouter = createTRPCRouter({
                     });
                 }
 
-                if (comment.announcement.classId !== input.classId) {
+                if (comment.announcement!.classId !== input.classId) {
                     throw new TRPCError({
                         code: "FORBIDDEN",
                         message: "Comment does not belong to this class",