@studious-lms/server 1.4.9 → 1.6.0

package/src/services/announcement.ts

@@ -121,8 +121,8 @@ export async function createAnnouncementRecord(
 
   sendToMultiple({
     receiverIds: classData.students.map((s) => s.id),
-    title: `🔔 Announcement for ${classData.name}`,
-    content: remarks,
+    title: `New announcement in ${classData.name}`,
+    content: `${remarks}\n\n[View announcement](/class/${classId})`,
   }).catch((error) => {
     logger.error("Failed to send announcement notifications:", error);
   });

package/src/services/assignment.ts

@@ -23,9 +23,10 @@ import {
 } from "../models/assignment.js";
 import { createDirectUploadFiles, type UploadedFile } from "../lib/fileUpload.js";
 import { deleteFile } from "../lib/googleCloudStorage.js";
-import { gradeWorksheetPipeline } from "../pipelines/gradeWorksheet.js";
 import { sendToMultiple } from "./notification.js";
+import { enqueueRunJob, QUEUE_NAMES } from "../workers/queues.js";
 import { logger } from "../utils/logger.js";
+import { RunJobType } from "@prisma/client";
 
 export async function assignmentExists(id: string) {
   const assignment = await findAssignmentById(id);
@@ -312,8 +313,8 @@ export async function createAssignmentRecord(
 
   sendToMultiple({
     receiverIds: (studentIds && studentIds.length > 0) ? studentIds : classData.students.map((s) => s.id),
-    title: `New assignment for ${classData.name}`,
-    content: `The assignment "${title}" has been created in ${classData.name}.\nDue date: ${new Date(dueDate).toLocaleDateString()}.\n[Link to assignment](/class/${classId}/assignments/${assignment.id})`,
+    title: `New assignment in ${classData.name}`,
+    content: `"${title}" is due ${new Date(dueDate).toLocaleDateString()}.\n\n[View assignment](/class/${classId}/assignments/${assignment.id})`,
   }).catch((error) => {
     logger.error("Failed to send assignment notifications:", error);
   });
@@ -664,9 +665,22 @@ export async function updateSubmissionRecord(
     ) {
       const worksheetResponses = await prisma.studentWorksheetResponse.findMany({
         where: { submissionId: submission.id },
+        select: { id: true },
       });
       for (const wr of worksheetResponses) {
-        gradeWorksheetPipeline(wr.id);
+        try {
+          await enqueueRunJob(
+            QUEUE_NAMES.GRADE_WORKSHEET as RunJobType,
+            { worksheetResponseId: wr.id },
+            { classId: submission.assignment.classId, userId },
+          );
+        } catch (error) {
+          logger.error("Failed to enqueue worksheet grading on submit", {
+            error,
+            worksheetResponseId: wr.id,
+            submissionId: submission.id,
+          });
+        }
       }
     }
     return prisma.submission.update({

package/src/services/attendance.ts

@@ -14,6 +14,8 @@ import {
   createAttendanceForEvent,
   updateAttendance,
 } from "../models/attendance.js";
+import { sendToMultiple } from "./notification.js";
+import { logger } from "../utils/logger.js";
 
 /** Get attendance for a class (optionally filtered by event). Creates missing records. */
 export async function getAttendance(classId: string, eventId?: string) {
@@ -66,20 +68,103 @@ export async function updateAttendanceRecord(
   const presentIds = attendance.present.map((s) => s.id);
   const lateIds = attendance.late.map((s) => s.id);
   const absentIds = attendance.absent.map((s) => s.id);
+  const previousLateIds = new Set(existing?.late.map((student) => student.id) ?? []);
+  const previousAbsentIds = new Set(existing?.absent.map((student) => student.id) ?? []);
+  const classStudentIds = new Set(classData.students.map((student) => student.id));
 
   if (!existing) {
-    return createAttendance({
+    const created = await createAttendance({
       classId,
       eventId: eventId ?? null,
       presentIds,
       lateIds,
       absentIds,
     });
+    await notifyMarkedLateOrAbsent({
+      classId,
+      className: classData.name,
+      eventId: eventId ?? null,
+      eventName: created.event?.name ?? null,
+      classStudentIds,
+      lateIds,
+      absentIds,
+      previousLateIds,
+      previousAbsentIds,
+    });
+    return created;
   }
 
-  return updateAttendance(existing.id, {
+  const updated = await updateAttendance(existing.id, {
     presentIds,
     lateIds,
     absentIds,
   });
+  await notifyMarkedLateOrAbsent({
+    classId,
+    className: classData.name,
+    eventId: eventId ?? null,
+    eventName: existing.event?.name ?? null,
+    classStudentIds,
+    lateIds,
+    absentIds,
+    previousLateIds,
+    previousAbsentIds,
+  });
+  return updated;
+}
+
+/** Notify only students whose late or absent status is newly added. */
+async function notifyMarkedLateOrAbsent(input: {
+  classId: string;
+  className: string;
+  eventId: string | null;
+  eventName: string | null;
+  classStudentIds: Set<string>;
+  lateIds: string[];
+  absentIds: string[];
+  previousLateIds: Set<string>;
+  previousAbsentIds: Set<string>;
+}) {
+  const lateReceiverIds = [...new Set(input.lateIds)].filter(
+    (id) => input.classStudentIds.has(id) && !input.previousLateIds.has(id)
+  );
+  const absentReceiverIds = [...new Set(input.absentIds)].filter(
+    (id) => input.classStudentIds.has(id) && !input.previousAbsentIds.has(id)
+  );
+  const link = input.eventId
+    ? `/class/${input.classId}/attendance/${input.eventId}`
+    : `/class/${input.classId}/attendance`;
+  const attendanceLabel = input.eventName
+    ? `"${input.eventName}" in ${input.className}`
+    : input.className;
+
+  await Promise.all([
+    sendAttendanceNotification({
+      receiverIds: lateReceiverIds,
+      title: `Marked late in ${input.className}`,
+      content: `You were marked late for ${attendanceLabel}.\n[View attendance](${link})`,
+    }),
+    sendAttendanceNotification({
+      receiverIds: absentReceiverIds,
+      title: `Marked absent in ${input.className}`,
+      content: `You were marked absent for ${attendanceLabel}.\n[View attendance](${link})`,
+    }),
+  ]);
+}
+
+/** Send attendance notifications without failing the attendance update itself. */
+async function sendAttendanceNotification(input: {
+  receiverIds: string[];
+  title: string;
+  content: string;
+}) {
+  if (input.receiverIds.length === 0) {
+    return;
+  }
+
+  try {
+    await sendToMultiple(input);
+  } catch (error) {
+    logger.error("Failed to send attendance notifications:", { error });
+  }
 }

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, RunJobType } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { chatChannel, teacherChannel, pusher } from "../lib/pusher.js";
 import {
@@ -17,9 +17,10 @@ import {
   findLabChatForDelete,
   findMentionedMemberships,
 } from "../models/labChat.js";
-import { generateAndSendLabIntroduction, generateAndSendLabResponse } from "../pipelines/aiLabChat.js";
-import { isAIUser } from "../utils/aiUser.js";
+import { getAIUserId, isAIUser } from "../utils/aiUser.js";
+import { createPendingAIMessage } from "../utils/inference.js";
 import { logger } from "../utils/logger.js";
+import { enqueueRunJob, QUEUE_NAMES } from "../workers/queues.js";
 import {
   claimMessageAttachments,
   ensureMessageHasContentOrAttachments,
@@ -125,12 +126,23 @@ export async function createLabChat(
     return labChat;
   });
 
-  generateAndSendLabIntroduction(
-    result.id,
-    result.conversationId,
-    context,
-    classWithTeachers.subject || "Lab"
-  );
+  // Create the AI introduction placeholder *outside* the transaction (the
+  // helper triggers Pusher and we don't want a tx rollback to leave a
+  // dangling broadcast). The pipeline will fill this row in.
+  try {
+    const aiPlaceholder = await createPendingAIMessage(result.conversationId);
+    await enqueueRunJob(
+      QUEUE_NAMES.AI_LAB_CHAT as RunJobType,
+      { conversationId: result.conversationId, aiMessageId: aiPlaceholder.id },
+      { classId, userId },
+    );
+  } catch (error) {
+    logger.error("Failed to enqueue lab chat introduction", {
+      error,
+      labChatId: result.id,
+      conversationId: result.conversationId,
+    });
+  }
 
   try {
     await pusher.trigger(teacherChannel(classId), "lab-chat-created", {
@@ -172,11 +184,13 @@ export async function getLabChat(userId: string, labChatId: string) {
     });
   }
 
+  // The AI placeholder row IS the pending generation marker now — its
+  // status flips PENDING → COMPLETED / FAILED as the pipeline runs.
   const pendingMessage = await prisma.message.findFirst({
     where: {
       conversationId: labChat.conversationId,
-      status: GenerationStatus.PENDING,
-      senderId: { not: "AI_ASSISTANT" },
+      status: JobStatus.PENDING,
+      senderId: getAIUserId(),
     },
     orderBy: { createdAt: "desc" },
     select: { id: true },
@@ -252,7 +266,6 @@ export async function postToLabChat(
         content: normalizedContent,
         senderId: userId,
         conversationId: labChat.conversationId,
-        ...(isAIUser(userId) ? {} : { status: GenerationStatus.PENDING }),
       },
     });
 
@@ -309,6 +322,7 @@ export async function postToLabChat(
         content: result.content,
         senderId: result.senderId,
         conversationId: result.conversationId,
+        status: result.status,
         createdAt: result.createdAt,
         sender: result.sender,
         attachments: result.attachments ?? [],
@@ -321,26 +335,49 @@ export async function postToLabChat(
   }
 
   if (!isAIUser(userId)) {
+    // Create the AI placeholder post-tx so a transaction rollback can never
+    // leave a dangling PENDING bubble. The placeholder broadcast IS the
+    // "AI is thinking..." indicator inline in the chat; the teacher-channel
+    // event below drives the lab list "AI busy in this lab" pill.
+    let aiPlaceholderId: string | null = null;
+    try {
+      const aiPlaceholder = await createPendingAIMessage(labChat.conversationId);
+      aiPlaceholderId = aiPlaceholder.id;
+    } catch (error) {
+      logger.error("Failed to create AI placeholder for lab response", {
+        error,
+        labChatId,
+        teacherMessageId: result.id,
+        conversationId: labChat.conversationId,
+      });
+    }
+
     try {
       await pusher.trigger(teacherChannel(labChat.classId), "lab-response-pending", {
         labChatId,
-        messageId: result.id,
+        messageId: aiPlaceholderId ?? result.id,
         conversationId: labChat.conversationId,
       });
     } catch (error) {
       console.error("Failed to broadcast lab response pending:", error);
     }
-    generateAndSendLabResponse(labChatId, normalizedContent, {
-      classId: labChat.classId,
-      messageId: result.id,
-    }).catch((error) =>
-      logger.error("Failed to generate lab response", {
-        error,
-        labChatId,
-        messageId: result.id,
-        conversationId: labChat.conversationId,
-      })
-    );
+
+    if (aiPlaceholderId) {
+      try {
+        await enqueueRunJob(
+          QUEUE_NAMES.AI_LAB_CHAT as RunJobType,
+          { conversationId: labChat.conversationId, aiMessageId: aiPlaceholderId },
+          { classId: labChat.classId, userId },
+        );
+      } catch (error) {
+        logger.error("Failed to enqueue lab response", {
+          error,
+          labChatId,
+          aiMessageId: aiPlaceholderId,
+          conversationId: labChat.conversationId,
+        });
+      }
+    }
   }
 
   return {
@@ -348,6 +385,7 @@ export async function postToLabChat(
     content: result.content,
     senderId: result.senderId,
     conversationId: result.conversationId,
+    status: result.status,
     createdAt: result.createdAt,
     sender: result.sender,
     attachments: result.attachments ?? [],
@@ -406,7 +444,13 @@ export async function deleteLabChat(userId: string, labChatId: string) {
   return { success: true };
 }
 
-/** Rerun the last AI response for a lab chat. Deletes the last AI message and regenerates. */
+/**
+ * Rerun the last AI response in a lab chat.
+ *
+ * The AI message bubble is reused (not deleted): we flip it back to
+ * PENDING and clear its content so the existing message id stays stable
+ * for the client. The pipeline then refills it.
+ */
 export async function rerunLastResponse(userId: string, labChatId: string) {
   const labChat = await findLabChatForPost(labChatId, userId);
   if (!labChat) {
@@ -446,46 +490,62 @@ export async function rerunLastResponse(userId: string, labChatId: string) {
     });
   }
 
-  await prisma.$transaction([
-    prisma.message.delete({
-      where: { id: lastMessage.id },
-    }),
-    prisma.message.update({
-      where: { id: teacherMessage.id },
-      data: { status: GenerationStatus.PENDING },
-    }),
-  ]);
+  const reusedAiMessage = await prisma.message.update({
+    where: { id: lastMessage.id },
+    data: {
+      content: "",
+      status: JobStatus.PENDING,
+      meta: {},
+    },
+    select: { id: true, conversationId: true, status: true, content: true, senderId: true, createdAt: true },
+  });
 
+  // Tell the chat UI the existing AI bubble is regenerating — content
+  // cleared, status flipped back to PENDING, same id.
   try {
-    await pusher.trigger(chatChannel(labChat.conversationId), "message-deleted", {
-      messageId: lastMessage.id,
-      conversationId: labChat.conversationId,
-      senderId: lastMessage.senderId,
+    await pusher.trigger(chatChannel(labChat.conversationId), "message-updated", {
+      id: reusedAiMessage.id,
+      content: reusedAiMessage.content,
+      senderId: reusedAiMessage.senderId,
+      conversationId: reusedAiMessage.conversationId,
+      status: reusedAiMessage.status,
+      createdAt: reusedAiMessage.createdAt,
+      sender: {
+        id: reusedAiMessage.senderId,
+        username: 'Newton_AI',
+        profile: { displayName: 'Newton AI', profilePicture: null },
+      },
+      mentionedUserIds: [],
+      meta: {},
+      attachments: [],
     });
   } catch (error) {
-    console.error("Failed to broadcast message deletion:", error);
+    console.error("Failed to broadcast AI message rerun reset:", error);
   }
   try {
     await pusher.trigger(teacherChannel(labChat.classId), "lab-response-pending", {
       labChatId,
-      messageId: teacherMessage.id,
+      messageId: reusedAiMessage.id,
       conversationId: labChat.conversationId,
     });
   } catch (error) {
     console.error("Failed to broadcast lab response pending:", error);
   }
 
-  generateAndSendLabResponse(labChatId, teacherMessage.content, {
-    classId: labChat.classId,
-    messageId: teacherMessage.id,
-  }).catch((error) =>
-    logger.error("Failed to generate lab response", {
+  try {
+    await enqueueRunJob(
+      QUEUE_NAMES.AI_LAB_CHAT as RunJobType,
+      { conversationId: labChat.conversationId, aiMessageId: reusedAiMessage.id },
+      { classId: labChat.classId, userId },
+    );
+  } catch (error) {
+    logger.error("Failed to enqueue lab response rerun", {
       error,
       labChatId,
-      messageId: teacherMessage.id,
+      aiMessageId: reusedAiMessage.id,
       conversationId: labChat.conversationId,
-    })
-  );
+    });
+  }
 
   return { success: true };
 }

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,
@@ -179,6 +192,7 @@ export async function listMessages(
       conversationId: message.conversationId,
       createdAt: message.createdAt,
       sender: message.sender,
+      status: message.status,
       attachments: message.attachments.map((a) => ({
         id: a.id,
         name: a.name,
@@ -303,6 +317,7 @@ export async function sendMessage(
         content: result.content,
         senderId: result.senderId,
         conversationId: result.conversationId,
+        status: result.status,
         createdAt: result.createdAt,
         sender: result.sender,
         attachments: result.attachments ?? [],
@@ -323,6 +338,7 @@ export async function sendMessage(
     content: result.content,
     senderId: result.senderId,
     conversationId: result.conversationId,
+    status: result.status,
     createdAt: result.createdAt,
     sender: result.sender,
     attachments: result.attachments ?? [],
@@ -427,6 +443,7 @@ export async function updateMessage(
         content: updatedMessage.content,
         senderId: updatedMessage.senderId,
         conversationId: updatedMessage.conversationId,
+        status: updatedMessage.status,
         createdAt: updatedMessage.createdAt,
         sender: updatedMessage.sender,
         attachments: updatedMessage.attachments ?? [],
@@ -447,6 +464,7 @@ export async function updateMessage(
     content: updatedMessage.content,
     senderId: updatedMessage.senderId,
     conversationId: updatedMessage.conversationId,
+    status: updatedMessage.status,
     createdAt: updatedMessage.createdAt,
     sender: updatedMessage.sender,
     mentionedUserIds,
@@ -620,6 +638,7 @@ export async function markSuggestionCreated(
               content: updated.content,
               senderId: updated.senderId,
               conversationId: updated.conversationId,
+              status: updated.status,
               createdAt: updated.createdAt,
               sender: updated.sender,
               attachments: updated.attachments ?? [],

package/src/services/newtonChat.ts

@@ -6,7 +6,8 @@ import { TRPCError } from "@trpc/server";
 import { logger } from "../utils/logger.js";
 import { chatChannel, pusher } from "../lib/pusher.js";
 import { isAIUser } from "../utils/aiUser.js";
-import { generateAndSendNewtonIntroduction, generateAndSendNewtonResponse } from "../pipelines/aiNewtonChat.js";
+import { createPendingAIMessage } from "../utils/inference.js";
+import { enqueueRunJob, QUEUE_NAMES } from "../workers/queues.js";
 import {
   claimMessageAttachments,
   ensureMessageHasContentOrAttachments,
@@ -18,6 +19,7 @@ import {
   findConversationMembersByUserIds,
 } from "../models/newtonChat.js";
 import { prisma } from "../lib/prisma.js";
+import { RunJobType } from "@prisma/client";
 
 /** Get or create Newton tutor conversation for a submission. Student-only. */
 export async function getTutorConversation(
@@ -44,7 +46,7 @@ export async function getTutorConversation(
     });
   }
 
-  const result = await prisma.$transaction(async (tx) => {
+  const { chat, isNew } = await prisma.$transaction(async (tx) => {
     const existingNewtonChat = await tx.newtonChat.findFirst({
       where: { submissionId: submission.id },
       include: {
@@ -60,7 +62,7 @@ export async function getTutorConversation(
     });
 
     if (existingNewtonChat && existingNewtonChat.conversation.members.length > 0) {
-      return existingNewtonChat;
+      return { chat: existingNewtonChat, isNew: false };
     }
 
     if (existingNewtonChat) {
@@ -71,7 +73,7 @@ export async function getTutorConversation(
           role: "MEMBER",
         },
       });
-      return existingNewtonChat;
+      return { chat: existingNewtonChat, isNew: false };
     }
 
     const conversation = await tx.conversation.create({
@@ -98,23 +100,31 @@ export async function getTutorConversation(
       },
     });
 
-    generateAndSendNewtonIntroduction(
-      newtonChat.id,
-      newtonChat.conversationId,
-      submission.id
-    ).catch((error) => {
-      logger.error("Failed to generate AI introduction:", {
+    return { chat: newtonChat, isNew: true };
+  });
+
+  if (isNew) {
+    // Create the AI introduction placeholder and enqueue OUTSIDE the
+    // transaction — a tx rollback would otherwise orphan a job pointing at
+    // a non-existent NewtonChat / Message row.
+    try {
+      const aiPlaceholder = await createPendingAIMessage(chat.conversationId);
+      await enqueueRunJob(
+        QUEUE_NAMES.AI_NEWTON_CHAT as RunJobType,
+        { conversationId: chat.conversationId, aiMessageId: aiPlaceholder.id },
+        { userId },
+      );
+    } catch (error) {
+      logger.error("Failed to enqueue Newton introduction", {
         error,
-        newtonChatId: newtonChat.id,
+        newtonChatId: chat.id,
       });
-    });
-
-    return newtonChat;
-  });
+    }
+  }
 
   return {
-    conversationId: result.conversationId,
-    newtonChatId: result.id,
+    conversationId: chat.conversationId,
+    newtonChatId: chat.id,
   };
 }
 
@@ -218,6 +228,7 @@ export async function postToNewtonChat(
         content: result.content,
         senderId: result.senderId,
         conversationId: result.conversationId,
+        status: result.status,
         createdAt: result.createdAt,
         sender: result.sender,
         attachments: result.attachments ?? [],
@@ -230,14 +241,23 @@ export async function postToNewtonChat(
   }
 
   if (!isAIUser(userId)) {
-    generateAndSendNewtonResponse(
-      newtonChatId,
-      normalizedContent,
-      newtonChat.conversationId,
-      newtonChat.submission
-    ).catch((error) => {
-      logger.error("Failed to generate AI response:", { error });
-    });
+    // Create the AI placeholder post-tx (so a rollback can't broadcast a
+    // ghost bubble); the pipeline fills it in.
+    try {
+      const aiPlaceholder = await createPendingAIMessage(newtonChat.conversationId);
+      await enqueueRunJob(
+        QUEUE_NAMES.AI_NEWTON_CHAT as RunJobType,
+        { conversationId: newtonChat.conversationId, aiMessageId: aiPlaceholder.id },
+        { userId },
+      );
+    } catch (error) {
+      logger.error("Failed to enqueue Newton response", {
+        error,
+        newtonChatId,
+        studentMessageId: result.id,
+        conversationId: newtonChat.conversationId,
+      });
+    }
   }
 
   return {
@@ -245,6 +265,7 @@ export async function postToNewtonChat(
     content: result.content,
     senderId: result.senderId,
     conversationId: result.conversationId,
+    status: result.status,
     createdAt: result.createdAt,
     sender: result.sender,
     attachments: result.attachments ?? [],