@studious-lms/server 1.4.9 → 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/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

@@ -3,7 +3,7 @@
  */
 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,
@@ -463,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/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/services/labChat.ts

@@ -3,7 +3,7 @@
  * trigger AI responses, and broadcast via Pusher.
  */
 import { TRPCError } from "@trpc/server";
-import { GenerationStatus } from "@prisma/client";
+import { JobStatus } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { chatChannel, teacherChannel, pusher } from "../lib/pusher.js";
 import {
@@ -175,7 +175,7 @@ export async function getLabChat(userId: string, labChatId: string) {
   const pendingMessage = await prisma.message.findFirst({
     where: {
       conversationId: labChat.conversationId,
-      status: GenerationStatus.PENDING,
+      status: JobStatus.PENDING,
       senderId: { not: "AI_ASSISTANT" },
     },
     orderBy: { createdAt: "desc" },
@@ -252,7 +252,7 @@ export async function postToLabChat(
         content: normalizedContent,
         senderId: userId,
         conversationId: labChat.conversationId,
-        ...(isAIUser(userId) ? {} : { status: GenerationStatus.PENDING }),
+        ...(isAIUser(userId) ? {} : { status: JobStatus.PENDING }),
       },
     });
 
@@ -452,7 +452,7 @@ export async function rerunLastResponse(userId: string, labChatId: string) {
     }),
     prisma.message.update({
       where: { id: teacherMessage.id },
-      data: { status: GenerationStatus.PENDING },
+      data: { status: JobStatus.PENDING },
     }),
   ]);
 

package/src/services/message.ts

@@ -110,6 +110,19 @@ export async function confirmMessageUpload(
     });
   }
 
+  if (input.uploadSuccess) {
+    await prisma.$transaction(async (tx) => {
+      await tx.file.update({
+        where: { id: input.fileId },
+        data: { uploadStatus: "FAILED", uploadError: input.errorMessage },
+      });
+    });
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Failed to confirm upload",
+    });
+  }
+
   const file = await prisma.file.findFirst({
     where: {
       id: input.fileId,

package/src/services/school.ts

@@ -1,13 +1,23 @@
 /**
  * School service - school admin workflow, memberships, and invites.
  */
-import { SchoolMembershipRole } from "@prisma/client";
+import { SchoolMembershipRole, SessionType } from "@prisma/client";
 import { TRPCError } from "@trpc/server";
+import { hash } from "bcryptjs";
 import { v4 as uuidv4 } from "uuid";
 import { env } from "../lib/config/env.js";
 import { prisma } from "../lib/prisma.js";
 import { sendMail } from "../utils/email.js";
+import { generateUniqueUsername } from "../utils/generateUsername.js";
 import { logger } from "../utils/logger.js";
+import {
+  createSession,
+  createUser,
+  findUserByEmail,
+  findUserById,
+  findUserByUsername,
+} from "../models/auth.js";
+import { upsertUserProfile } from "../models/user.js";
 import {
   acceptSchoolInvite,
   countActiveAdmins,
@@ -16,7 +26,6 @@ import {
   findActiveSchoolAdminMembership,
   findPendingInviteByToken,
   findSchoolMembership,
-  findUserByIdForSchool,
   getSchoolById,
   getSchoolOverview,
   listSchoolClasses,
@@ -225,9 +234,61 @@ export async function listInvites(userId: string, schoolId: string) {
 
 export async function createInvite(
   userId: string,
-  input: { schoolId: string; email: string; role: SchoolMembershipRole }
+  input: {
+    schoolId: string;
+    email: string;
+    role: SchoolMembershipRole;
+    username?: string;
+    displayName?: string;
+  }
 ) {
   await requireSchoolAdmin(input.schoolId, userId);
+
+  const existingUser = await findUserByEmail(input.email);
+
+  let createdUser: { id: string; username: string } | null = null;
+  let passwordResetToken: string | null = null;
+
+  if (!existingUser) {
+    let username: string;
+    if (input.username) {
+      const taken = await findUserByUsername(input.username);
+      if (taken) {
+        throw new TRPCError({
+          code: "CONFLICT",
+          message: "Username already taken",
+        });
+      }
+      username = input.username;
+    } else {
+      username = await generateUniqueUsername(async (candidate) => {
+        const existing = await findUserByUsername(candidate);
+        return Boolean(existing);
+      });
+    }
+
+    const placeholderPassword = await hash(uuidv4(), 10);
+    const user = await createUser({
+      username,
+      email: input.email,
+      password: placeholderPassword,
+      verified: true,
+    });
+    createdUser = { id: user.id, username: user.username };
+
+    if (input.displayName) {
+      await upsertUserProfile(user.id, { displayName: input.displayName });
+    }
+
+    const resetSession = await createSession({
+      id: uuidv4(),
+      type: SessionType.PASSWORD_RESET,
+      userId: user.id,
+      expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 14),
+    });
+    passwordResetToken = resetSession.id;
+  }
+
   const token = uuidv4();
   const invite = await createSchoolInvite({
     schoolId: input.schoolId,
@@ -238,12 +299,34 @@ export async function createInvite(
     expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 14),
   });
 
+  if (createdUser) {
+    await acceptSchoolInvite(invite.id, createdUser.id);
+  }
+
+  const inviteUrl = `${env.NEXT_PUBLIC_APP_URL}/school/invite/${token}`;
+  const passwordResetUrl = passwordResetToken
+    ? `${env.NEXT_PUBLIC_APP_URL}/reset-password/${passwordResetToken}`
+    : null;
+
+  const emailLines = [
+    `You've been invited to ${invite.school.name} on Studious.`,
+    "",
+  ];
+  if (createdUser && passwordResetUrl) {
+    emailLines.push(
+      `We created an account for you with the username "${createdUser.username}" and added you to ${invite.school.name}.`,
+      `Set your password to get started: ${passwordResetUrl}`
+    );
+  } else {
+    emailLines.push(`Click the link to confirm: ${inviteUrl}`);
+  }
+
   try {
     await sendMail({
       from: "hello@studious.sh",
       to: input.email,
       subject: `Join ${invite.school.name} on Studious`,
-      text: `Click the link to join ${invite.school.name}: ${env.NEXT_PUBLIC_APP_URL}/school/invite/${token}`,
+      text: emailLines.join("\n"),
     });
   } catch (err) {
     logger.error("Failed to send school invite email", {
@@ -253,7 +336,7 @@ export async function createInvite(
     });
   }
 
-  return { invite };
+  return { invite, createdUser };
 }
 
 export async function revokeInvite(
@@ -292,7 +375,7 @@ export async function acceptInvite(userId: string, token: string) {
     throw new TRPCError({ code: "UNAUTHORIZED", message: "Invite expired" });
   }
 
-  const user = await findUserByIdForSchool(userId);
+  const user = await findUserById(userId);
   if (!user) {
     throw new TRPCError({ code: "NOT_FOUND", message: "User not found" });
   }

package/src/services/worksheet.ts

@@ -3,7 +3,7 @@
  * Integrates with gradeWorksheet pipeline for auto-grading.
  */
 import { TRPCError } from "@trpc/server";
-import { GenerationStatus, type WorksheetQuestionType } from "@prisma/client";
+import { JobStatus, type WorksheetQuestionType } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { getFileUrl } from "../lib/fileUpload.js";
 import { cancelGradePipeline, regradeWorksheetPipeline } from "../pipelines/gradeWorksheet.js";
@@ -283,24 +283,22 @@ export async function reorderWorksheetQuestions(
       message: "Target question not found",
     });
   }
+  if (movedId === targetId) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Moved question and target question must be different",
+    });
+  }
 
   const withoutMoved = questions.filter((q) => q.id !== movedId);
-  const next =
-    position === "before"
-      ? [
-          ...withoutMoved.slice(0, targetIdx).map((item) => ({ id: item.id })),
-          { id: movedId },
-          ...withoutMoved.slice(targetIdx).map((item) => ({ id: item.id })),
-        ]
-      : [
-          ...withoutMoved
-            .slice(0, targetIdx + 1)
-            .map((item) => ({ id: item.id })),
-          { id: movedId },
-          ...withoutMoved
-            .slice(targetIdx + 1)
-            .map((item) => ({ id: item.id })),
-        ];
+  const targetIdxWithoutMoved = withoutMoved.findIndex((q) => q.id === targetId);
+  const insertIdx =
+    position === "before" ? targetIdxWithoutMoved : targetIdxWithoutMoved + 1;
+  const next = [
+    ...withoutMoved.slice(0, insertIdx).map((item) => ({ id: item.id })),
+    { id: movedId },
+    ...withoutMoved.slice(insertIdx).map((item) => ({ id: item.id })),
+  ];
 
   await prisma.$transaction(
     next.map((item, index) =>
@@ -432,7 +430,7 @@ export async function answerWorksheetQuestion(
       ...(isMarkableByAlgo && {
         points: response === correctAnswer ? marksAwardedIfCorrect : 0,
       }),
-      status: GenerationStatus.NOT_STARTED,
+      status: JobStatus.NOT_STARTED,
     });
   } else {
     await createStudentQuestionProgress({