@studious-lms/server 1.2.53 → 1.4.0

package/src/services/labChat.ts

@@ -0,0 +1,458 @@
+/**
+ * Lab chat service – AI-powered lab conversations. Create lab chats, post messages,
+ * trigger AI responses, and broadcast via Pusher.
+ */
+import { TRPCError } from "@trpc/server";
+import { GenerationStatus } from "@prisma/client";
+import { prisma } from "../lib/prisma.js";
+import { chatChannel, teacherChannel, pusher } from "../lib/pusher.js";
+import {
+  findClassWithTeachersForLab,
+  findLabChatByMember,
+  findLabChatByTeacher,
+  findLabChatById,
+  findClassMembership,
+  findLabChatsByClass,
+  findLabChatForPost,
+  findLabChatForDelete,
+  findMentionedMemberships,
+} from "../models/labChat.js";
+import { generateAndSendLabIntroduction, generateAndSendLabResponse } from "../pipelines/aiLabChat.js";
+import { isAIUser } from "../utils/aiUser.js";
+
+/** Create a lab chat with conversation and teacher members. Broadcasts via Pusher. */
+export async function createLabChat(
+  userId: string,
+  input: { classId: string; title: string; context: string }
+) {
+  const { classId, title, context } = input;
+
+  const classWithTeachers = await findClassWithTeachersForLab(classId, userId);
+  if (!classWithTeachers) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a teacher in this class",
+    });
+  }
+
+  try {
+    JSON.parse(context);
+  } catch {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Context must be valid JSON",
+    });
+  }
+
+  const result = await prisma.$transaction(async (tx) => {
+    const conversation = await tx.conversation.create({
+      data: {
+        type: "GROUP",
+        name: `Lab: ${title}`,
+        displayInChat: false,
+      },
+    });
+
+    const teacherMembers = classWithTeachers.teachers.map((t) => ({
+      userId: t.id,
+      role: "ADMIN" as const,
+    }));
+
+    await tx.conversationMember.createMany({
+      data: teacherMembers.map((member) => ({
+        userId: member.userId,
+        conversationId: conversation.id,
+        role: member.role,
+      })),
+    });
+
+    const labChat = await tx.labChat.create({
+      data: {
+        title,
+        context,
+        classId,
+        conversationId: conversation.id,
+        createdById: userId,
+      },
+      include: {
+        conversation: {
+          include: {
+            members: {
+              include: {
+                user: {
+                  select: {
+                    id: true,
+                    username: true,
+                    profile: {
+                      select: {
+                        displayName: true,
+                        profilePicture: true,
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        createdBy: {
+          select: {
+            id: true,
+            username: true,
+            profile: {
+              select: {
+                displayName: true,
+              },
+            },
+          },
+        },
+        class: {
+          select: {
+            id: true,
+            name: true,
+            subject: true,
+            section: true,
+          },
+        },
+      },
+    });
+
+    return labChat;
+  });
+
+  generateAndSendLabIntroduction(
+    result.id,
+    result.conversationId,
+    context,
+    classWithTeachers.subject || "Lab"
+  );
+
+  try {
+    await pusher.trigger(teacherChannel(classId), "lab-chat-created", {
+      id: result.id,
+      title: result.title,
+      classId: result.classId,
+      conversationId: result.conversationId,
+      createdBy: result.createdBy,
+      createdAt: result.createdAt,
+    });
+  } catch (error) {
+    console.error("Failed to broadcast lab chat creation:", error);
+  }
+
+  return result;
+}
+
+export async function getLabChat(userId: string, labChatId: string) {
+  let labChat = await findLabChatByMember(labChatId, userId);
+
+  if (!labChat) {
+    const labChatForTeacher = await findLabChatByTeacher(labChatId, userId);
+    if (labChatForTeacher) {
+      await prisma.conversationMember.create({
+        data: {
+          userId,
+          conversationId: labChatForTeacher.conversation.id,
+          role: "ADMIN",
+        },
+      });
+      labChat = await findLabChatById(labChatId);
+    }
+  }
+
+  if (!labChat) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Lab chat not found or access denied",
+    });
+  }
+
+  const pendingMessage = await prisma.message.findFirst({
+    where: {
+      conversationId: labChat.conversationId,
+      status: GenerationStatus.PENDING,
+      senderId: { not: "AI_ASSISTANT" },
+    },
+    orderBy: { createdAt: "desc" },
+    select: { id: true },
+  });
+
+  return {
+    ...labChat,
+    pendingGenerationMessageId: pendingMessage?.id ?? null,
+  };
+}
+
+export async function listLabChats(userId: string, classId: string) {
+  const classMembership = await findClassMembership(classId, userId);
+  if (!classMembership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a member of this class",
+    });
+  }
+
+  const labChats = await findLabChatsByClass(classId);
+  return labChats.map((labChat) => ({
+    id: labChat.id,
+    title: labChat.title,
+    classId: labChat.classId,
+    conversationId: labChat.conversationId,
+    createdBy: labChat.createdBy,
+    createdAt: labChat.createdAt,
+    updatedAt: labChat.updatedAt,
+    lastMessage: labChat.conversation.messages[0] || null,
+    messageCount: labChat.conversation._count.messages,
+  }));
+}
+
+export async function postToLabChat(
+  userId: string,
+  input: {
+    labChatId: string;
+    content: string;
+    mentionedUserIds?: string[];
+  }
+) {
+  const { labChatId, content, mentionedUserIds = [] } = input;
+
+  const labChat = await findLabChatForPost(labChatId, userId);
+  if (!labChat) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Lab chat not found or access denied",
+    });
+  }
+
+  if (mentionedUserIds.length > 0) {
+    const mentionedMemberships = await findMentionedMemberships(
+      labChat.conversationId,
+      mentionedUserIds
+    );
+    if (mentionedMemberships.length !== mentionedUserIds.length) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Some mentioned users are not members of this lab chat",
+      });
+    }
+  }
+
+  const result = await prisma.$transaction(async (tx) => {
+    const message = await tx.message.create({
+      data: {
+        content,
+        senderId: userId,
+        conversationId: labChat.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.labChat.update({
+      where: { id: labChatId },
+      data: { updatedAt: new Date() },
+    });
+
+    return message;
+  });
+
+  try {
+    await pusher.trigger(
+      chatChannel(labChat.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 lab chat message:", error);
+  }
+
+  if (!isAIUser(userId)) {
+    await prisma.message.update({
+      where: { id: result.id },
+      data: { status: GenerationStatus.PENDING },
+    });
+    try {
+      await pusher.trigger(teacherChannel(labChat.classId), "lab-response-pending", {
+        labChatId,
+        messageId: result.id,
+        conversationId: labChat.conversationId,
+      });
+    } catch (error) {
+      console.error("Failed to broadcast lab response pending:", error);
+    }
+    generateAndSendLabResponse(
+      labChatId,
+      content,
+      labChat.conversationId,
+      { classId: labChat.classId, messageId: result.id }
+    );
+  }
+
+  return {
+    id: result.id,
+    content: result.content,
+    senderId: result.senderId,
+    conversationId: result.conversationId,
+    createdAt: result.createdAt,
+    sender: result.sender,
+    mentionedUserIds,
+  };
+}
+
+export async function deleteLabChat(userId: string, labChatId: string) {
+  const labChat = await findLabChatForDelete(labChatId, userId);
+  if (!labChat) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Lab chat not found or not the creator",
+    });
+  }
+
+  await prisma.$transaction(async (tx) => {
+    await tx.mention.deleteMany({
+      where: {
+        message: {
+          conversationId: labChat.conversationId,
+        },
+      },
+    });
+
+    await tx.message.deleteMany({
+      where: {
+        conversationId: labChat.conversationId,
+      },
+    });
+
+    await tx.conversationMember.deleteMany({
+      where: {
+        conversationId: labChat.conversationId,
+      },
+    });
+
+    await tx.labChat.delete({
+      where: { id: labChatId },
+    });
+
+    await tx.conversation.delete({
+      where: { id: labChat.conversationId },
+    });
+  });
+
+  try {
+    await pusher.trigger(teacherChannel(labChat.classId), "lab-chat-deleted", {
+      labChatId,
+      classId: labChat.classId,
+    });
+  } catch (error) {
+    console.error("Failed to broadcast lab chat deletion:", error);
+  }
+
+  return { success: true };
+}
+
+/** Rerun the last AI response for a lab chat. Deletes the last AI message and regenerates. */
+export async function rerunLastResponse(userId: string, labChatId: string) {
+  const labChat = await findLabChatForPost(labChatId, userId);
+  if (!labChat) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Lab chat not found or access denied",
+    });
+  }
+
+  const messages = await prisma.message.findMany({
+    where: { conversationId: labChat.conversationId },
+    orderBy: { createdAt: "desc" },
+    take: 10,
+    select: { id: true, content: true, senderId: true, createdAt: true },
+  });
+
+  const lastMessage = messages[0];
+  if (!lastMessage) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "No messages to rerun",
+    });
+  }
+
+  if (!isAIUser(lastMessage.senderId)) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Last message is not from AI – nothing to rerun",
+    });
+  }
+
+  const teacherMessage = messages.find((m) => !isAIUser(m.senderId));
+  if (!teacherMessage) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "No teacher message found to rerun from",
+    });
+  }
+
+  await prisma.message.delete({
+    where: { id: lastMessage.id },
+  });
+
+  try {
+    await pusher.trigger(chatChannel(labChat.conversationId), "message-deleted", {
+      messageId: lastMessage.id,
+      conversationId: labChat.conversationId,
+      senderId: lastMessage.senderId,
+    });
+  } catch (error) {
+    console.error("Failed to broadcast message deletion:", error);
+  }
+
+  await prisma.message.update({
+    where: { id: teacherMessage.id },
+    data: { status: GenerationStatus.PENDING },
+  });
+  try {
+    await pusher.trigger(teacherChannel(labChat.classId), "lab-response-pending", {
+      labChatId,
+      messageId: teacherMessage.id,
+      conversationId: labChat.conversationId,
+    });
+  } catch (error) {
+    console.error("Failed to broadcast lab response pending:", error);
+  }
+
+  generateAndSendLabResponse(
+    labChatId,
+    teacherMessage.content,
+    labChat.conversationId,
+    { classId: labChat.classId, messageId: teacherMessage.id }
+  );
+
+  return { success: true };
+}

package/src/services/marketing.ts

@@ -0,0 +1,57 @@
+/**
+ * Marketing service – school development programs and early access requests.
+ */
+import { v4 } from "uuid";
+import {
+  createSchoolDevelopmentProgram,
+  findSchoolDevelopmentProgramById,
+  createEarlyAccessRequest,
+} from "../models/marketing.js";
+
+/** Create a school development program application. Generates unique ID. */
+export async function createSchoolDevelopmentProgramRecord(input: {
+  name: string;
+  type: string;
+  address: string;
+  city: string;
+  country: string;
+  numberOfStudents: number;
+  numberOfTeachers: number;
+  website?: string;
+  contactName?: string;
+  contactRole?: string;
+  contactEmail?: string;
+  contactPhone?: string;
+  eligibilityInformation?: string;
+  whyHelp?: string;
+  additionalInformation?: string;
+}) {
+  const date = new Date();
+  const id =
+    input.name.slice(0, 3).toUpperCase() +
+    "-" +
+    date.getFullYear() +
+    "-" +
+    v4().slice(0, 4).toUpperCase();
+
+  const program = await createSchoolDevelopmentProgram({
+    id,
+    ...input,
+  });
+
+  return { id: program.id };
+}
+
+/** Look up a school development program by ID. */
+export async function searchSchoolDevelopmentPrograms(id: string) {
+  return findSchoolDevelopmentProgramById(id);
+}
+
+/** Create an early access request. */
+export async function createEarlyAccessRequestRecord(input: {
+  email: string;
+  institutionSize: string;
+}) {
+  const record = await createEarlyAccessRequest(input);
+  return { id: record.id };
+}