@studious-lms/server 1.4.7 → 1.5.0

package/src/lib/config/cors.ts

@@ -8,8 +8,6 @@ type CorsEnv = {
 const productionOrigins = [
   'https://www.studious.sh',
   'https://studious.sh',
-  'https://dev.studious.sh',
-  'https://www.dev.studious.sh',
 ];
 
 const nonProductionOrigins = [

package/src/lib/fileUpload.ts

@@ -189,6 +189,7 @@ export async function createDirectUploadFile(
         uploadUrl,
         uploadExpiresAt,
         uploadSessionId,
+        uploadedAt: null,
         user: {
           connect: { id: userId }
         },
@@ -292,6 +293,7 @@ export async function confirmDirectUpload(
     const updateData: any = {
       uploadStatus: actualUploadSuccess ? 'COMPLETED' : 'FAILED',
       uploadProgress: actualUploadSuccess ? 100 : 0,
+      uploadedAt: actualUploadSuccess ? new Date() : null,
     };
     
     if (!actualUploadSuccess && actualErrorMessage) {
@@ -299,10 +301,6 @@ export async function confirmDirectUpload(
       updateData.uploadRetryCount = { increment: 1 };
     }
     
-    if (actualUploadSuccess) {
-      updateData.uploadedAt = new Date();
-    }
-    
     await prisma.file.update({
       where: { id: fileId },
       data: updateData

package/src/models/assignment.ts

@@ -2,6 +2,7 @@
  * Assignment model – assignments, submissions, attachments.
  */
 import { prisma } from "../lib/prisma.js";
+import { duplicateWorksheetWithClient } from "./worksheet.js";
 import {
   classMemberOrSchoolAdminWhere,
   classTeacherOrSchoolAdminWhere,
@@ -214,6 +215,137 @@ export function findAssignmentWithClassForTeacher(assignmentId: string, teacherI
   });
 }
 
+/**
+ * Clone an assignment into another class with a new title: copies settings, duplicates linked
+ * worksheets into the target class, clones attachment file records (same storage path),
+ * creates empty submissions for all students in the target class, and does not copy the
+ * calendar event link or per-student “assigned to” overrides.
+ */
+export async function duplicateAssignment(
+  sourceAssignmentId: string,
+  targetClassId: string,
+  title: string,
+  duplicatingUserId: string
+) {
+  return prisma.$transaction(
+    async (tx) => {
+      const source = await tx.assignment.findUnique({
+        where: { id: sourceAssignmentId },
+        include: {
+          worksheets: { select: { id: true, name: true } },
+          attachments: {
+            select: { name: true, type: true, size: true, path: true },
+          },
+          section: { select: { id: true, name: true } },
+        },
+      });
+
+      if (!source) {
+        return null;
+      }
+
+      let targetSectionId: string | undefined;
+      if (source.sectionId && source.section) {
+        const match = await tx.section.findFirst({
+          where: { classId: targetClassId, name: source.section.name },
+          select: { id: true },
+        });
+        targetSectionId = match?.id;
+      }
+
+      const newWorksheetIds: string[] = [];
+      for (const ws of source.worksheets) {
+        const dup = await duplicateWorksheetWithClient(
+          tx,
+          ws.id,
+          targetClassId,
+          ws.name
+        );
+        if (dup) {
+          newWorksheetIds.push(dup.id);
+        }
+      }
+
+      const classData = await tx.class.findUnique({
+        where: { id: targetClassId },
+        include: { students: { select: { id: true } } },
+      });
+      if (!classData) {
+        return null;
+      }
+
+      const submissionData = classData.students.map((s) => ({
+        student: { connect: { id: s.id } },
+      }));
+
+      const created = await tx.assignment.create({
+        data: {
+          title,
+          instructions: source.instructions,
+          dueDate: source.dueDate,
+          teacher: { connect: { id: duplicatingUserId } },
+          class: { connect: { id: targetClassId } },
+          acceptFiles: source.acceptFiles,
+          acceptExtendedResponse: source.acceptExtendedResponse,
+          acceptWorksheet: source.acceptWorksheet,
+          gradeWithAI: source.gradeWithAI,
+          aiPolicyLevel: source.aiPolicyLevel,
+          graded: source.graded,
+          maxGrade: source.maxGrade,
+          weight: source.weight,
+          type: source.type,
+          inProgress: source.inProgress,
+          template: source.template,
+          ...(source.markSchemeId && {
+            markScheme: { connect: { id: source.markSchemeId } },
+          }),
+          ...(source.gradingBoundaryId && {
+            gradingBoundary: { connect: { id: source.gradingBoundaryId } },
+          }),
+          ...(targetSectionId && {
+            section: { connect: { id: targetSectionId } },
+          }),
+          ...(newWorksheetIds.length > 0 && {
+            worksheets: { connect: newWorksheetIds.map((id) => ({ id })) },
+          }),
+          submissions: { create: submissionData },
+          order: 0,
+        },
+      });
+
+      await tx.assignment.updateMany({
+        where: { classId: targetClassId, id: { not: created.id } },
+        data: { order: { increment: 1 } },
+      });
+      await tx.section.updateMany({
+        where: { classId: targetClassId },
+        data: { order: { increment: 1 } },
+      });
+      await tx.assignment.update({
+        where: { id: created.id },
+        data: { order: 1 },
+      });
+
+      for (const file of source.attachments) {
+        await tx.file.create({
+          data: {
+            name: file.name,
+            type: file.type,
+            size: file.size ?? 0,
+            path: file.path,
+            uploadStatus: "COMPLETED",
+            user: { connect: { id: duplicatingUserId } },
+            assignment: { connect: { id: created.id } },
+          },
+        });
+      }
+
+      return created;
+    },
+    { maxWait: 10000, timeout: 60000 }
+  );
+}
+
 /** @returns Submissions for assignment (teacher view). */
 export function findSubmissionsByAssignmentForTeacher(assignmentId: string, teacherId: string) {
   return prisma.submission.findMany({

package/src/models/auth.ts

@@ -82,6 +82,7 @@ export function findUserById(id: string) {
     select: {
       id: true,
       username: true,
+      email: true,
       profile: {
         select: {
           displayName: true,

package/src/models/school.ts

@@ -248,20 +248,6 @@ export function removeSchoolMembershipPreservingContent(schoolId: string, userId
   });
 }
 
-export function findUserByEmailForSchool(email: string) {
-  return prisma.user.findFirst({
-    where: { email },
-    select: { id: true, email: true, username: true },
-  });
-}
-
-export function findUserByIdForSchool(userId: string) {
-  return prisma.user.findUnique({
-    where: { id: userId },
-    select: { id: true, email: true, username: true },
-  });
-}
-
 export function createSchoolInvite(data: {
   schoolId: string;
   invitedById: string;

package/src/models/worksheet.ts

@@ -1,8 +1,9 @@
 /**
  * Worksheet model – worksheets, questions, submissions, student progress, grading.
  */
+import type { Prisma } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
-import type { WorksheetQuestionType, GenerationStatus } from "@prisma/client";
+import type { WorksheetQuestionType, JobStatus } from "@prisma/client";
 import {
   classMemberOrSchoolAdminWhere,
   classTeacherOrSchoolAdminWhere,
@@ -115,6 +116,59 @@ export function deleteWorksheet(id: string) {
   });
 }
 
+/**
+ * Clone a worksheet and its questions into another class with a new name.
+ * Does not copy student responses or assignment links.
+ */
+export async function duplicateWorksheetWithClient(
+  tx: Prisma.TransactionClient,
+  sourceWorksheetId: string,
+  targetClassId: string,
+  name: string
+) {
+  const source = await tx.worksheet.findUnique({
+    where: { id: sourceWorksheetId },
+    include: {
+      questions: { orderBy: { order: "asc" } },
+    },
+  });
+
+  if (!source) {
+    return null;
+  }
+
+  const created = await tx.worksheet.create({
+    data: { classId: targetClassId, name },
+  });
+
+  if (source.questions.length > 0) {
+    await tx.worksheetQuestion.createMany({
+      data: source.questions.map((q) => ({
+        worksheetId: created.id,
+        type: q.type,
+        question: q.question,
+        answer: q.answer,
+        points: q.points,
+        options: q.options ?? undefined,
+        markScheme: q.markScheme ?? undefined,
+        order: q.order,
+      })),
+    });
+  }
+
+  return created;
+}
+
+export async function duplicateWorksheet(
+  sourceWorksheetId: string,
+  targetClassId: string,
+  name: string
+) {
+  return prisma.$transaction((tx) =>
+    duplicateWorksheetWithClient(tx, sourceWorksheetId, targetClassId, name)
+  );
+}
+
 /** @returns Questions for a worksheet. */
 export function findQuestionsByWorksheetId(worksheetId: string) {
   return prisma.worksheetQuestion.findMany({
@@ -409,7 +463,7 @@ export function updateStudentQuestionProgress(
     response?: string;
     isCorrect?: boolean;
     points?: number;
-    status?: GenerationStatus;
+    status?: JobStatus;
   }
 ) {
   return prisma.studentQuestionProgress.update({

package/src/pipelines/aiLabChat.ts

@@ -4,7 +4,7 @@
  */
 import { isAIUser } from "../utils/aiUser.js";
 import { prisma } from "../lib/prisma.js";
-import { GenerationStatus } from "@prisma/client";
+import { JobStatus } from "@prisma/client";
 import { pusher, teacherChannel } from "../lib/pusher.js";
 import type { Assignment, Class, File, Section, User } from "@prisma/client";
 import { inference, sendAIMessage } from "../utils/inference.js";
@@ -314,7 +314,7 @@ export const getBaseSystemPrompt = (
 //             content: "GENERATING_CONTENT",
 //             senderId: getAIUserId(),
 //             conversationId: labChatId,
-//             status: GenerationStatus.PENDING,   
+//             status: JobStatus.PENDING,
 //         },
 //     });
 
@@ -599,7 +599,7 @@ export const generateAndSendLabIntroduction = async (
       if (emitOptions) {
         await prisma.message.update({
           where: { id: emitOptions.messageId },
-          data: { status: GenerationStatus.COMPLETED },
+          data: { status: JobStatus.COMPLETED },
         });
         try {
           await pusher.trigger(teacherChannel(emitOptions.classId), "lab-response-completed", {
@@ -628,7 +628,7 @@ export const generateAndSendLabIntroduction = async (
         try {
           await prisma.message.update({
             where: { id: emitOptions.messageId },
-            data: { status: GenerationStatus.FAILED },
+            data: { status: JobStatus.FAILED },
           });
         } catch (statusError) {
           logger.error("Failed to set message status FAILED:", {

package/src/pipelines/gradeWorksheet.ts

@@ -2,7 +2,7 @@
  * Grade worksheet pipeline – AI-powered grading of worksheet responses.
  * Grades questions via inference API, broadcasts status via Pusher (pending/completed/failed/cancelled).
  */
-import { GenerationStatus, WorksheetQuestionType } from "@prisma/client";
+import { JobStatus, WorksheetQuestionType } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { logger } from "../utils/logger.js";
 import z from "zod";
@@ -113,11 +113,11 @@ const gradeWorksheetQuestion = async (worksheetResponseId: string, worksheetQues
         const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.update({
             where: { id: studentQuestionProgress.id, status: {
                 not: {
-                    in: ['CANCELLED'],
+                    in: [JobStatus.CANCELLED],
                 },
             } },
             data: {
-                status: GenerationStatus.COMPLETED,
+                status: JobStatus.COMPLETED,
                 isCorrect: (apiResponse as { isCorrect: boolean }).isCorrect,
                 points: (apiResponse as { points: number }).points,
                 markschemeState: (apiResponse as {
@@ -143,13 +143,23 @@ const gradeWorksheetQuestion = async (worksheetResponseId: string, worksheetQues
         return updatedStudentQuestionProgress;
     } catch (error) {
         logger.error('Failed to grade worksheet response', { error, worksheetResponseId });
+        const { count } = await prisma.studentQuestionProgress.updateMany({
+            where: {
+                id: studentQuestionProgress.id,
+                status: { not: JobStatus.CANCELLED },
+            },
+            data: { status: JobStatus.FAILED },
+        });
+        if (count === 0) {
+            logger.info('Skipping failed status update for cancelled worksheet question', {
+                worksheetResponseId,
+                worksheetQuestionProgressId,
+            });
+            return;
+        }
         pusher.trigger(worksheetChannel(worksheetResponse.id), `set-failed`, {
             id: studentQuestionProgress.id,
         });
-        await prisma.studentQuestionProgress.update({
-            where: { id: studentQuestionProgress.id },
-            data: { status: GenerationStatus.FAILED },
-        });
         throw error;
     }
 }
@@ -160,7 +170,7 @@ const gradeWorksheetQuestion = async (worksheetResponseId: string, worksheetQues
  * @returns updated worksheet response
  */
 
-const DO_NOT_INFERENCE_STATUSES = [GenerationStatus.CANCELLED, GenerationStatus.PENDING, GenerationStatus.COMPLETED];
+const DO_NOT_INFERENCE_STATUSES = [JobStatus.CANCELLED, JobStatus.PENDING, JobStatus.COMPLETED];
 
 export const gradeWorksheetPipeline = async (worksheetResponseId: string) => {
     logger.info('Grading worksheet response', { worksheetResponseId });
@@ -200,17 +210,20 @@ export const gradeWorksheetPipeline = async (worksheetResponseId: string) => {
     for (const response of worksheetResponse.responses) {
         logger.info('Grading question', { questionId: response.questionId });
 
-        const studentQuestionProgress = await prisma.studentQuestionProgress.update({
-            where: { id: response.id, status: {
-                not: {
-                    in: DO_NOT_INFERENCE_STATUSES,
-                }
-            } },
-            data: { status: GenerationStatus.PENDING },
+        const { count } = await prisma.studentQuestionProgress.updateMany({
+            where: {
+                id: response.id,
+                status: {
+                    not: {
+                        in: DO_NOT_INFERENCE_STATUSES,
+                    },
+                },
+            },
+            data: { status: JobStatus.PENDING },
         });
 
-        if (studentQuestionProgress.status !== GenerationStatus.PENDING) {
-            return;
+        if (count === 0) {
+            continue;
         }
 
         await gradeWorksheetQuestion(worksheetResponseId, response.id);
@@ -233,7 +246,7 @@ export const cancelGradePipeline = async (worksheetResponseId: string, worksheet
     }
     const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.update({
         where: { id: worksheetQuestionProgressId },
-        data: { status: GenerationStatus.CANCELLED },
+        data: { status: JobStatus.CANCELLED },
     });
 
     await removeAllPreviousAIComments(worksheetQuestionProgressId);
@@ -255,26 +268,51 @@ export const regradeWorksheetPipeline = async (worksheetResponseId: string, work
         },
     });
     
-    await removeAllPreviousAIComments(worksheetQuestionProgressId);
-
     if (!worksheetResponse) {
         logger.error('Worksheet response not found');
         throw new Error('Worksheet response not found');
     }
 
-    const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.update({
+    const { count } = await prisma.studentQuestionProgress.updateMany({
+        where: {
+            id: worksheetQuestionProgressId,
+            status: { not: JobStatus.CANCELLED },
+        },
+        data: { status: JobStatus.PENDING },
+    });
+
+    if (count === 0) {
+        logger.info('Skipping regrade for cancelled worksheet question', {
+            worksheetResponseId,
+            worksheetQuestionProgressId,
+        });
+        return null;
+    }
+
+    const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.findUnique({
         where: { id: worksheetQuestionProgressId },
-        data: { status: GenerationStatus.PENDING },
     });
 
+    await removeAllPreviousAIComments(worksheetQuestionProgressId);
+
     await gradeWorksheetQuestion(worksheetResponseId, worksheetQuestionProgressId);
 
     return updatedStudentQuestionProgress;
     } catch (error) {
-        await prisma.studentQuestionProgress.update({
-            where: { id: worksheetQuestionProgressId },
-            data: { status: GenerationStatus.FAILED },
+        const { count } = await prisma.studentQuestionProgress.updateMany({
+            where: {
+                id: worksheetQuestionProgressId,
+                status: { not: JobStatus.CANCELLED },
+            },
+            data: { status: JobStatus.FAILED },
         });
+        if (count === 0) {
+            logger.info('Skipping failed status update for cancelled worksheet question regrade', {
+                worksheetResponseId,
+                worksheetQuestionProgressId,
+            });
+            return null;
+        }
         const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
             where: { id: worksheetResponseId, },
             include: {

package/src/pipelines/pdfToWorksheet.ts

@@ -4,6 +4,7 @@
  */
 import { z } from "zod";
 import type { ResponseInput } from "openai/resources/responses/responses.js";
+import { Prisma } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { inference } from "../utils/inference.js";
 import { logger } from "../utils/logger.js";
@@ -109,15 +110,33 @@ If no answer is provided for a multiple-choice or true/false question, determine
  * structured inference, and inserts worksheet + questions in one DB transaction.
  */
 export async function pdfToWorksheet(gcsUrl: string, classId: string) {
-  const sanitizedUrl = sanitizeUrlForLogs(gcsUrl);
+  const sourceUrl = sanitizeUrlForLogs(gcsUrl);
 
   if (!isProbablyGoogleCloudUrl(gcsUrl)) {
     logger.warn("pdfToWorksheet: rejected unsupported PDF URL", {
-      sanitizedUrl,
+      sanitizedUrl: sourceUrl,
     });
     throw new Error("Only Google Cloud Storage URLs are supported");
   }
 
+  const existingWorksheet = await prisma.worksheet.findUnique({
+    where: {
+      classId_sourceUrl: {
+        classId,
+        sourceUrl,
+      },
+    },
+  });
+
+  if (existingWorksheet) {
+    logger.info("pdfToWorksheet: reusing existing worksheet for source PDF", {
+      worksheetId: existingWorksheet.id,
+      classId,
+      sourceUrl,
+    });
+    return existingWorksheet;
+  }
+
   const filename = getFilenameFromUrl(gcsUrl);
   const prompt = `Read the attached PDF and convert it into a single worksheet JSON object.\n\n${schemaInstructions}`;
 
@@ -149,29 +168,56 @@ export async function pdfToWorksheet(gcsUrl: string, classId: string) {
     return null;
   }
 
-  return prisma.$transaction(async (tx) => {
-    const worksheet = await tx.worksheet.create({
-      data: { classId, name: draft.title },
-    });
+  try {
+    return await prisma.$transaction(async (tx) => {
+      const worksheet = await tx.worksheet.create({
+        data: { classId, name: draft.title, sourceUrl },
+      });
 
-    if (draft.questions.length > 0) {
-      await tx.worksheetQuestion.createMany({
-        data: draft.questions.map((question) => ({
-          worksheetId: worksheet.id,
-          type: question.type,
-          question: question.question,
-          answer: question.answer,
-          points: Math.round(question.points ?? 0),
-          options: question.options ?? [],
-          markScheme: (question.markScheme ?? []).map((item) => ({
-            ...item,
-            points: Math.round(item.points),
+      if (draft.questions.length > 0) {
+        await tx.worksheetQuestion.createMany({
+          data: draft.questions.map((question) => ({
+            worksheetId: worksheet.id,
+            type: question.type,
+            question: question.question,
+            answer: question.answer,
+            points: Math.round(question.points ?? 0),
+            options: question.options ?? [],
+            markScheme: (question.markScheme ?? []).map((item) => ({
+              ...item,
+              points: Math.round(item.points),
+            })),
+            order: Math.round(question.order),
           })),
-          order: Math.round(question.order),
-        })),
+        });
+      }
+
+      return worksheet;
+    });
+  } catch (error) {
+    if (
+      error instanceof Prisma.PrismaClientKnownRequestError &&
+      error.code === "P2002"
+    ) {
+      const worksheet = await prisma.worksheet.findUnique({
+        where: {
+          classId_sourceUrl: {
+            classId,
+            sourceUrl,
+          },
+        },
       });
+
+      if (worksheet) {
+        logger.info("pdfToWorksheet: reused worksheet created by concurrent retry", {
+          worksheetId: worksheet.id,
+          classId,
+          sourceUrl,
+        });
+        return worksheet;
+      }
     }
 
-    return worksheet;
-  });
+    throw error;
+  }
 }

package/src/routers/assignment.ts

@@ -18,6 +18,7 @@ import {
   getSubmissionById,
   getSubmissions,
   createAssignmentRecord,
+  duplicateAssignmentRecord,
   updateAssignmentRecord,
   deleteAssignmentRecord,
   updateSubmissionRecord,
@@ -273,6 +274,24 @@ export const assignmentRouter = createTRPCRouter({
   create: protectedTeacherProcedure
     .input(createAssignmentSchema)
     .mutation(({ ctx, input }) => createAssignmentRecord(ctx.user!.id, input)),
+
+  duplicateAssignment: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        title: z.string(),
+        assignmentId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      duplicateAssignmentRecord(
+        input.assignmentId,
+        input.classId,
+        input.title,
+        ctx.user!.id
+      )
+    ),
+
   update: protectedTeacherProcedure
     .input(updateAssignmentSchema)
     .mutation(({ ctx, input }) => updateAssignmentRecord(ctx.user!.id, input)),

package/src/routers/school.ts

@@ -104,6 +104,11 @@ export const schoolRouter = createTRPCRouter({
         schoolId: z.string(),
         email: z.string().email(),
         role: schoolRoleSchema,
+        username: z
+          .string()
+          .min(3, "Username must be at least 3 characters")
+          .optional(),
+        displayName: z.string().min(1).optional(),
       })
     )
     .mutation(({ ctx, input }) => createInvite(ctx.user!.id, input)),

package/src/routers/worksheet.ts

@@ -19,6 +19,7 @@ import {
   updateWorksheetRecord,
   deleteWorksheetRecord,
   createWorksheetRecord,
+  duplicateWorksheetRecord,
   createWorksheetFromPdf,
   createWorksheetFromUploadedPdf,
   addQuestionToWorksheet,
@@ -108,6 +109,23 @@ export const worksheetRouter = createTRPCRouter({
       createWorksheetRecord(input.classId, input.name)
     ),
 
+  duplicateWorksheet: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        name: z.string(),
+        worksheetId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      duplicateWorksheetRecord(
+        input.worksheetId,
+        input.classId,
+        input.name,
+        ctx.user!.id
+      )
+    ),
+
   createFromPdf: protectedTeacherProcedure
     .input(z.object({ classId: z.string(), url: z.string().url() }))
     .mutation(({ input }) => createWorksheetFromPdf(input.classId, input.url)),