@studious-lms/server 1.2.53 → 1.4.0

package/src/services/newtonChat.ts

@@ -0,0 +1,222 @@
+/**
+ * Newton chat service – AI tutor conversations for assignments. Get or create
+ * tutor session, post messages, trigger AI responses. Broadcasts via Pusher.
+ */
+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 {
+  findClassWithStudent,
+  findSubmissionByAssignmentAndStudent,
+  findNewtonChatByIdAndMember,
+  findConversationMembersByUserIds,
+} from "../models/newtonChat.js";
+import { prisma } from "../lib/prisma.js";
+
+/** Get or create Newton tutor conversation for a submission. Student-only. */
+export async function getTutorConversation(
+  userId: string,
+  assignmentId: string,
+  classId: string
+) {
+  const classMembership = await findClassWithStudent(classId, userId);
+  if (!classMembership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a student in this class",
+    });
+  }
+
+  const submission = await findSubmissionByAssignmentAndStudent(
+    assignmentId,
+    userId
+  );
+  if (!submission) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Submission not found. Please create a submission first.",
+    });
+  }
+
+  const result = await prisma.$transaction(async (tx) => {
+    const existingNewtonChat = await tx.newtonChat.findFirst({
+      where: { submissionId: submission.id },
+      include: {
+        conversation: {
+          include: {
+            members: {
+              where: { userId },
+            },
+          },
+        },
+      },
+      orderBy: { createdAt: "desc" },
+    });
+
+    if (existingNewtonChat && existingNewtonChat.conversation.members.length > 0) {
+      return existingNewtonChat;
+    }
+
+    if (existingNewtonChat) {
+      await tx.conversationMember.create({
+        data: {
+          userId,
+          conversationId: existingNewtonChat.conversationId,
+          role: "MEMBER",
+        },
+      });
+      return existingNewtonChat;
+    }
+
+    const conversation = await tx.conversation.create({
+      data: {
+        type: "DM",
+        name: "Session with Newton Tutor",
+        displayInChat: false,
+      },
+    });
+
+    await tx.conversationMember.create({
+      data: {
+        userId,
+        conversationId: conversation.id,
+        role: "MEMBER",
+      },
+    });
+
+    const newtonChat = await tx.newtonChat.create({
+      data: {
+        submissionId: submission.id,
+        conversationId: conversation.id,
+        title: "Session with Newton Tutor",
+      },
+    });
+
+    generateAndSendNewtonIntroduction(
+      newtonChat.id,
+      newtonChat.conversationId,
+      submission.id
+    ).catch((error) => {
+      logger.error("Failed to generate AI introduction:", {
+        error,
+        newtonChatId: newtonChat.id,
+      });
+    });
+
+    return newtonChat;
+  });
+
+  return {
+    conversationId: result.conversationId,
+    newtonChatId: result.id,
+  };
+}
+
+export async function postToNewtonChat(
+  userId: string,
+  newtonChatId: string,
+  content: string,
+  mentionedUserIds: string[] = []
+) {
+  const newtonChat = await findNewtonChatByIdAndMember(newtonChatId, userId);
+  if (!newtonChat) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Newton chat not found or access denied",
+    });
+  }
+
+  if (mentionedUserIds.length > 0) {
+    const mentionedMemberships = await findConversationMembersByUserIds(
+      newtonChat.conversationId,
+      mentionedUserIds
+    );
+    if (mentionedMemberships.length !== mentionedUserIds.length) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Some mentioned users are not members of this conversation",
+      });
+    }
+  }
+
+  const result = await prisma.$transaction(async (tx) => {
+    const message = await tx.message.create({
+      data: {
+        content,
+        senderId: userId,
+        conversationId: newtonChat.conversationId,
+      },
+      include: {
+        sender: {
+          select: {
+            id: true,
+            username: true,
+            profile: {
+              select: {
+                displayName: true,
+                profilePicture: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (mentionedUserIds.length > 0) {
+      await tx.mention.createMany({
+        data: mentionedUserIds.map((mentionedUserId) => ({
+          messageId: message.id,
+          userId: mentionedUserId,
+        })),
+      });
+    }
+
+    await tx.newtonChat.update({
+      where: { id: newtonChatId },
+      data: { updatedAt: new Date() },
+    });
+
+    return message;
+  });
+
+  try {
+    await pusher.trigger(
+      chatChannel(newtonChat.conversationId),
+      "new-message",
+      {
+        id: result.id,
+        content: result.content,
+        senderId: result.senderId,
+        conversationId: result.conversationId,
+        createdAt: result.createdAt,
+        sender: result.sender,
+        mentionedUserIds,
+      }
+    );
+  } catch (error) {
+    console.error("Failed to broadcast newton chat message:", error);
+  }
+
+  if (!isAIUser(userId)) {
+    generateAndSendNewtonResponse(
+      newtonChatId,
+      content,
+      newtonChat.conversationId,
+      newtonChat.submission
+    ).catch((error) => {
+      logger.error("Failed to generate AI response:", { error });
+    });
+  }
+
+  return {
+    id: result.id,
+    content: result.content,
+    senderId: result.senderId,
+    conversationId: result.conversationId,
+    createdAt: result.createdAt,
+    sender: result.sender,
+    mentionedUserIds,
+  };
+}

package/src/services/notification.ts

@@ -0,0 +1,50 @@
+/**
+ * Notification service – list, send, and mark notifications as read.
+ */
+import {
+  findNotificationsByReceiverId,
+  findNotificationById,
+  createNotification,
+  createManyNotifications,
+  markNotificationAsRead,
+} from "../models/notification.js";
+
+/** List notifications for a user. */
+export async function listNotifications(userId: string) {
+  return findNotificationsByReceiverId(userId);
+}
+
+/** Get a single notification by ID. */
+export async function getNotification(id: string) {
+  return findNotificationById(id);
+}
+
+/** Send a notification to one user. */
+export async function sendNotification(input: {
+  receiverId: string;
+  title: string;
+  content: string;
+}) {
+  return createNotification(input);
+}
+
+/** Send the same notification to multiple users. */
+export async function sendToMultiple(input: {
+  receiverIds: string[];
+  title: string;
+  content: string;
+}) {
+  const result = await createManyNotifications(
+    input.receiverIds.map((receiverId) => ({
+      receiverId,
+      title: input.title,
+      content: input.content,
+    }))
+  );
+  return result;
+}
+
+/** Mark a notification as read. */
+export async function markAsRead(id: string) {
+  return markNotificationAsRead(id);
+}

package/src/services/section.ts

@@ -0,0 +1,283 @@
+/**
+ * Section service – CRUD for class sections. Handles reordering of sections
+ * and assignments in a unified list.
+ */
+import { TRPCError } from "@trpc/server";
+import {
+  findSectionById,
+  findClassWithTeacher,
+  createSection,
+  findSectionsByClassId,
+  findAssignmentsByClassId,
+  updateSectionOrder,
+  updateAssignmentOrder,
+  updateSection,
+  deleteSectionById,
+  findSectionByClassAndId,
+} from "../models/section.js";
+import { prisma } from "../lib/prisma.js";
+
+/** Check if a section exists. */
+export async function sectionExists(id: string) {
+  const section = await findSectionById(id);
+  return !!section;
+}
+
+/** Create a section and reorder the unified section/assignment list. */
+export async function createSectionRecord(
+  userId: string,
+  input: {
+    classId: string;
+    id?: string;
+    name: string;
+    color?: string;
+  }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  const section = await createSection({
+    id: input.id,
+    name: input.name,
+    order: 0,
+    classId: input.classId,
+    color: input.color,
+  });
+
+  const [sections, assignments] = await Promise.all([
+    findSectionsByClassId(input.classId),
+    findAssignmentsByClassId(input.classId),
+  ]);
+
+  const unified = [
+    ...sections.map((s) => ({ id: s.id, order: s.order, type: "section" as const })),
+    ...assignments.map((a) => ({ id: a.id, order: a.order, type: "assignment" as const })),
+  ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+
+  const withoutNew = unified.filter(
+    (item) => !(item.id === section.id && item.type === "section")
+  );
+  const reindexed = [
+    { id: section.id, type: "section" as const },
+    ...withoutNew.map((item) => ({ id: item.id, type: item.type })),
+  ];
+
+  await Promise.all(
+    reindexed.map((item, index) =>
+      item.type === "section"
+        ? updateSectionOrder(item.id, index + 1)
+        : updateAssignmentOrder(item.id, index + 1)
+    )
+  );
+
+  return section;
+}
+
+export async function reorderSection(
+  userId: string,
+  input: {
+    classId: string;
+    movedId: string;
+    position: "start" | "end" | "before" | "after";
+    targetId?: string;
+  }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "UNAUTHORIZED",
+      message: "Not authorized",
+    });
+  }
+
+  const moved = await findSectionByClassAndId(input.movedId, input.classId);
+  if (!moved) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Section not found",
+    });
+  }
+
+  if (
+    (input.position === "before" || input.position === "after") &&
+    !input.targetId
+  ) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "targetId required for before/after",
+    });
+  }
+
+  const result = await prisma.$transaction(async (tx) => {
+    const [sections, assignments] = await Promise.all([
+      tx.section.findMany({
+        where: { classId: input.classId },
+        select: { id: true, order: true },
+      }),
+      tx.assignment.findMany({
+        where: { classId: input.classId },
+        select: { id: true, order: true },
+      }),
+    ]);
+
+    const unified = [
+      ...sections.map((s) => ({ id: s.id, order: s.order, type: "section" as const })),
+      ...assignments.map((a) => ({ id: a.id, order: a.order, type: "assignment" as const })),
+    ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+
+    const movedIdx = unified.findIndex(
+      (item) => item.id === input.movedId && item.type === "section"
+    );
+    if (movedIdx === -1) {
+      throw new TRPCError({
+        code: "NOT_FOUND",
+        message: "Section not found in unified list",
+      });
+    }
+
+    const withoutMoved = unified.filter(
+      (item) => !(item.id === input.movedId && item.type === "section")
+    );
+
+    let next: Array<{ id: string; type: "section" | "assignment" }> = [];
+
+    if (input.position === "start") {
+      next = [
+        { id: input.movedId, type: "section" },
+        ...withoutMoved.map((item) => ({ id: item.id, type: item.type })),
+      ];
+    } else if (input.position === "end") {
+      next = [
+        ...withoutMoved.map((item) => ({ id: item.id, type: item.type })),
+        { id: input.movedId, type: "section" },
+      ];
+    } else {
+      const targetIdx = withoutMoved.findIndex((item) => item.id === input.targetId);
+      if (targetIdx === -1) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "targetId not found in unified list",
+        });
+      }
+      if (input.position === "before") {
+        next = [
+          ...withoutMoved.slice(0, targetIdx).map((item) => ({ id: item.id, type: item.type })),
+          { id: input.movedId, type: "section" },
+          ...withoutMoved.slice(targetIdx).map((item) => ({ id: item.id, type: item.type })),
+        ];
+      } else {
+        next = [
+          ...withoutMoved
+            .slice(0, targetIdx + 1)
+            .map((item) => ({ id: item.id, type: item.type })),
+          { id: input.movedId, type: "section" },
+          ...withoutMoved
+            .slice(targetIdx + 1)
+            .map((item) => ({ id: item.id, type: item.type })),
+        ];
+      }
+    }
+
+    await Promise.all(
+      next.map((item, index) =>
+        item.type === "section"
+          ? tx.section.update({ where: { id: item.id }, data: { order: index + 1 } })
+          : tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } })
+      )
+    );
+
+    return tx.section.findUnique({ where: { id: input.movedId } });
+  });
+
+  return result;
+}
+
+export async function updateSectionRecord(
+  userId: string,
+  input: {
+    id: string;
+    classId: string;
+    name: string;
+    color?: string;
+  }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  return updateSection(input.id, {
+    name: input.name,
+    color: input.color,
+  });
+}
+
+export async function reOrderSection(
+  userId: string,
+  input: { id: string; classId: string; order: number }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  await prisma.$transaction(async (tx) => {
+    await tx.section.update({
+      where: { id: input.id },
+      data: { order: input.order },
+    });
+
+    const [sections, assignments] = await Promise.all([
+      tx.section.findMany({
+        where: { classId: input.classId },
+        select: { id: true, order: true },
+      }),
+      tx.assignment.findMany({
+        where: { classId: input.classId },
+        select: { id: true, order: true },
+      }),
+    ]);
+
+    const unified = [
+      ...sections.map((s) => ({ id: s.id, order: s.order, type: "section" as const })),
+      ...assignments.map((a) => ({ id: a.id, order: a.order, type: "assignment" as const })),
+    ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
+
+    await Promise.all(
+      unified.map((item, index) =>
+        item.type === "section"
+          ? tx.section.update({ where: { id: item.id }, data: { order: index + 1 } })
+          : tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } })
+      )
+    );
+  });
+
+  return { id: input.id };
+}
+
+export async function deleteSectionRecord(
+  userId: string,
+  input: { id: string; classId: string }
+) {
+  const classData = await findClassWithTeacher(input.classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  await deleteSectionById(input.id);
+  return { id: input.id };
+}