@studious-lms/server 1.2.33 → 1.2.35

package/dist/routers/worksheet.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("src/trpc").Context;
+    ctx: import("../trpc.js").Context;
     meta: object;
     errorShape: {
         data: {
             zodError: z.typeToFlattenedError<any, string> | null;
-            prismaError: import("../utils/prismaErrorHandler").PrismaErrorInfo | null;
+            prismaError: import("../utils/prismaErrorHandler.js").PrismaErrorInfo | null;
             code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
             httpStatus: number;
             path?: string;
@@ -33,11 +33,12 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
             questions: {
                 type: import(".prisma/client").$Enums.WorksheetQuestionType;
                 id: string;
-                options: import("@prisma/client/runtime/library").JsonValue | null;
+                options: import("@prisma/client/runtime/library.js").JsonValue | null;
                 createdAt: Date;
                 order: number | null;
-                markScheme: import("@prisma/client/runtime/library").JsonValue | null;
+                markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
                 updatedAt: Date;
+                points: number;
                 question: string;
                 worksheetId: string;
                 answer: string;
@@ -117,15 +118,17 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
             answer: string;
             options?: any;
             markScheme?: any;
+            points?: number | undefined;
         };
         output: {
             type: import(".prisma/client").$Enums.WorksheetQuestionType;
             id: string;
-            options: import("@prisma/client/runtime/library").JsonValue | null;
+            options: import("@prisma/client/runtime/library.js").JsonValue | null;
             createdAt: Date;
             order: number | null;
-            markScheme: import("@prisma/client/runtime/library").JsonValue | null;
+            markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
             updatedAt: Date;
+            points: number;
             question: string;
             worksheetId: string;
             answer: string;
@@ -151,17 +154,19 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
             type?: "ESSAY" | "MULTIPLE_CHOICE" | "TRUE_FALSE" | "SHORT_ANSWER" | "LONG_ANSWER" | "MATH_EXPRESSION" | undefined;
             options?: any;
             markScheme?: any;
+            points?: number | undefined;
             question?: string | undefined;
             answer?: string | undefined;
         };
         output: {
             type: import(".prisma/client").$Enums.WorksheetQuestionType;
             id: string;
-            options: import("@prisma/client/runtime/library").JsonValue | null;
+            options: import("@prisma/client/runtime/library.js").JsonValue | null;
             createdAt: Date;
             order: number | null;
-            markScheme: import("@prisma/client/runtime/library").JsonValue | null;
+            markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
             updatedAt: Date;
+            points: number;
             question: string;
             worksheetId: string;
             answer: string;
@@ -176,11 +181,12 @@ export declare const worksheetRouter: import("@trpc/server").TRPCBuiltRouter<{
         output: {
             type: import(".prisma/client").$Enums.WorksheetQuestionType;
             id: string;
-            options: import("@prisma/client/runtime/library").JsonValue | null;
+            options: import("@prisma/client/runtime/library.js").JsonValue | null;
             createdAt: Date;
             order: number | null;
-            markScheme: import("@prisma/client/runtime/library").JsonValue | null;
+            markScheme: import("@prisma/client/runtime/library.js").JsonValue | null;
             updatedAt: Date;
+            points: number;
             question: string;
             worksheetId: string;
             answer: string;
@@ -198,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;
@@ -228,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;
@@ -256,54 +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").JsonValue | null;
-                    createdAt: Date;
-                    order: number | null;
-                    markScheme: import("@prisma/client/runtime/library").JsonValue | null;
-                    updatedAt: Date;
-                    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;
@@ -316,71 +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").JsonValue | null;
-                    createdAt: Date;
-                    order: number | null;
-                    markScheme: import("@prisma/client/runtime/library").JsonValue | null;
-                    updatedAt: Date;
-                    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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2KA,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsUhC,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

@@ -1,7 +1,7 @@
 import { TRPCError } from "@trpc/server";
-import { createTRPCRouter, protectedProcedure } from "src/trpc";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { z } from "zod";
-import { prisma } from "src/lib/prisma";
+import { prisma } from "../lib/prisma.js";
 export const worksheetRouter = createTRPCRouter({
     // Get a single worksheet with all questions
     getWorksheet: protectedProcedure
@@ -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,
             },
@@ -95,12 +96,13 @@ export const worksheetRouter = createTRPCRouter({
         worksheetId: z.string(),
         question: z.string(),
         answer: z.string(),
+        points: z.number().optional(),
         options: z.any().optional(), // JSON field
         markScheme: z.any().optional(), // JSON field
         type: z.enum(['MULTIPLE_CHOICE', 'TRUE_FALSE', 'SHORT_ANSWER', 'LONG_ANSWER', 'MATH_EXPRESSION', 'ESSAY']),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { worksheetId, question, answer, options, markScheme, type } = input;
+        const { worksheetId, question, points, answer, options, markScheme, type } = input;
         const worksheet = await prisma.worksheet.findUnique({
             where: { id: worksheetId },
         });
@@ -111,6 +113,7 @@ export const worksheetRouter = createTRPCRouter({
             data: {
                 worksheetId,
                 type,
+                points,
                 question,
                 answer,
                 options,
@@ -167,12 +170,13 @@ export const worksheetRouter = createTRPCRouter({
         questionId: z.string(),
         question: z.string().optional(),
         answer: z.string().optional(),
+        points: z.number().optional(),
         options: z.any().optional(), // JSON field
         markScheme: z.any().optional(), // JSON field
         type: z.enum(['MULTIPLE_CHOICE', 'TRUE_FALSE', 'SHORT_ANSWER', 'LONG_ANSWER', 'MATH_EXPRESSION', 'ESSAY']).optional(),
     }))
         .mutation(async ({ ctx, input }) => {
-        const { worksheetId, questionId, question, answer, options, markScheme, type } = input;
+        const { worksheetId, questionId, points, question, answer, options, markScheme, type } = input;
         const worksheet = await prisma.worksheet.findUnique({
             where: { id: worksheetId },
         });
@@ -187,6 +191,7 @@ export const worksheetRouter = createTRPCRouter({
                 ...(markScheme !== undefined && { markScheme }),
                 ...(type !== undefined && { type }),
                 ...(options !== undefined && { options }),
+                ...(points !== undefined && { points }),
             },
         });
         return updatedQuestion;
@@ -223,7 +228,7 @@ export const worksheetRouter = createTRPCRouter({
             throw new TRPCError({ code: 'NOT_FOUND', message: 'Submission not found' });
         }
         // Find or create worksheet response for this submission
-        const worksheetResponses = await prisma.$transaction(async (tx) => {
+        const worksheetResponse = await prisma.$transaction(async (tx) => {
             // First check if a response exists
             const existing = await tx.studentWorksheetResponse.findFirst({
                 where: {
@@ -250,7 +255,8 @@ export const worksheetRouter = createTRPCRouter({
             });
             return created;
         });
-        return worksheetResponses;
+        console.log(worksheetResponse);
+        return worksheetResponse;
     }),
     answerQuestion: protectedProcedure
         .input(z.object({
@@ -339,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.33",
+  "version": "1.2.35",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",

package/prisma/schema.prisma

@@ -108,7 +108,7 @@ model User {
   sentMessages Message[] @relation("SentMessages")
   mentions Mention[] @relation("UserMentions")
   createdLabChats LabChat[] @relation("CreatedLabChats")
-  announcementComments AnnouncementComment[]
+  comments Comment[]
   reactions Reaction[]
 
 }
@@ -292,23 +292,25 @@ model Announcement {
   class   Class @relation(fields: [classId], references: [id], onDelete: Cascade)
   classId String
   attachments File[] @relation("AnnouncementAttachments")
-  comments AnnouncementComment[]
+  comments Comment[]
   reactions Reaction[]
 }
 
-model AnnouncementComment {
+model Comment {
   id            String @id @default(uuid())
   content       String
   author        User @relation(fields: [authorId], references: [id], onDelete: Cascade)
   authorId      String
-  announcement  Announcement @relation(fields: [announcementId], references: [id], onDelete: Cascade)
-  announcementId String
-  parentComment AnnouncementComment? @relation("CommentReplies", fields: [parentCommentId], references: [id], onDelete: Cascade)
+  announcement  Announcement? @relation(fields: [announcementId], references: [id], onDelete: Cascade)
+  announcementId String?
+  parentComment Comment? @relation("CommentReplies", fields: [parentCommentId], references: [id], onDelete: Cascade)
   parentCommentId String?
-  replies       AnnouncementComment[] @relation("CommentReplies")
+  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 {
@@ -318,7 +320,7 @@ model Reaction {
   userId        String
   announcement  Announcement? @relation(fields: [announcementId], references: [id], onDelete: Cascade)
   announcementId String?
-  comment       AnnouncementComment? @relation(fields: [commentId], references: [id], onDelete: Cascade)
+  comment       Comment? @relation(fields: [commentId], references: [id], onDelete: Cascade)
   commentId     String?
   createdAt     DateTime @default(now())
   
@@ -517,6 +519,7 @@ model WorksheetQuestion {
   answer String
   options Json?  @default("{}")
   markScheme Json?  @default("{}")
+  points Int @default(0)
   order Int? @default(0)
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
@@ -546,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