@studious-lms/server 1.2.53 → 1.3.0

package/src/services/folder.ts

@@ -0,0 +1,316 @@
+/**
+ * Folder service – CRUD for class folders, file uploads, and folder hierarchy.
+ */
+import { TRPCError } from "@trpc/server";
+import {
+  findClassWithTeacher,
+  findFolderById,
+  findOrCreateRootFolder,
+  createFolder,
+  findFolderWithContents,
+  findChildFolders,
+  findRootFolderWithContents,
+  findFolderByIdWithCount,
+  deleteFolderById,
+  updateFolderParent,
+  updateFolder,
+  findFolderByIdForTraversal,
+} from "../models/folder.js";
+import { createDirectUploadFiles } from "../lib/fileUpload.js";
+
+/** Create a folder in a class. Teacher-only. */
+export async function createFolderRecord(
+  userId: string,
+  input: {
+    classId: string;
+    name: string;
+    parentFolderId?: string | null;
+    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",
+    });
+  }
+
+  let parentFolderId = input.parentFolderId;
+  if (!parentFolderId) {
+    const root = await findOrCreateRootFolder(input.classId);
+    parentFolderId = root.id;
+  } else {
+    const parentFolder = await findFolderById(parentFolderId);
+    if (!parentFolder) {
+      throw new TRPCError({
+        code: "NOT_FOUND",
+        message: "Parent folder not found",
+      });
+    }
+  }
+
+  return createFolder({
+    name: input.name,
+    parentFolderId,
+    color: input.color,
+  });
+}
+
+/** Get folder with its contents (subfolders and files). */
+export async function getFolder(folderId: string) {
+  const folder = await findFolderWithContents(folderId);
+  if (!folder) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Folder not found",
+    });
+  }
+  return folder;
+}
+
+export async function getChildFolders(classId: string) {
+  const root = await findOrCreateRootFolder(classId);
+  return findChildFolders(root.id);
+}
+
+export async function getFolderChildren(folderId: string, classId: string) {
+  return findChildFolders(folderId);
+}
+
+export async function getRootFolder(classId: string) {
+  const root = await findOrCreateRootFolder(classId);
+  const rootWithContents = await findRootFolderWithContents(classId);
+  if (!rootWithContents) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Root folder not found",
+    });
+  }
+  return rootWithContents;
+}
+
+export async function uploadFilesToFolder(
+  userId: string,
+  classId: string,
+  folderId: string,
+  files: { name: string; type: string; size: number }[]
+) {
+  const classData = await findClassWithTeacher(classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  const folder = await findFolderById(folderId);
+  if (!folder) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Folder not found",
+    });
+  }
+
+  const uploadedFiles = await createDirectUploadFiles(files, userId, folderId);
+  return {
+    success: true,
+    uploadedCount: uploadedFiles.length,
+  };
+}
+
+export async function deleteFolderRecord(
+  userId: string,
+  classId: string,
+  folderId: string
+) {
+  const classData = await findClassWithTeacher(classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  const folder = await findFolderByIdWithCount(folderId);
+  if (!folder) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Folder not found",
+    });
+  }
+
+  // Verify folder belongs to class (traverse to root)
+  let currentId: string | null = folderId;
+  let belongsToClass = false;
+  while (currentId) {
+    const current = await findFolderByIdForTraversal(currentId);
+    if (!current) break;
+    if (current.classId === classId) {
+      belongsToClass = true;
+      break;
+    }
+    currentId = current.parentFolderId;
+  }
+  if (!belongsToClass) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Folder does not belong to this class",
+    });
+  }
+
+  await deleteFolderById(folderId);
+  return {
+    success: true,
+    deletedFiles: folder._count.files,
+    deletedFolders: folder._count.childFolders + 1,
+  };
+}
+
+export async function moveFolder(
+  userId: string,
+  folderId: string,
+  targetParentFolderId: string,
+  classId: string
+) {
+  const classData = await findClassWithTeacher(classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You must be a teacher of this class to move folders",
+    });
+  }
+
+  const folder = await findFolderById(folderId);
+  if (!folder) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Folder not found",
+    });
+  }
+
+  if (!folder.parentFolderId) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Cannot move the root folder",
+    });
+  }
+
+  if (targetParentFolderId) {
+    const targetParent = await findFolderByIdForTraversal(targetParentFolderId);
+    if (!targetParent) {
+      throw new TRPCError({
+        code: "NOT_FOUND",
+        message: "Target parent folder not found",
+      });
+    }
+
+    if (targetParentFolderId === folderId) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Cannot move a folder into itself",
+      });
+    }
+
+    let currentParent: typeof targetParent | null = targetParent;
+    while (currentParent?.parentFolderId) {
+      if (currentParent.parentFolderId === folderId) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "Cannot move a folder into its descendant",
+        });
+      }
+      currentParent = await findFolderByIdForTraversal(currentParent.parentFolderId);
+      if (!currentParent) break;
+    }
+  }
+
+  return updateFolderParent(folderId, targetParentFolderId);
+}
+
+export async function updateFolderRecord(
+  folderId: string,
+  name: string,
+  color: string | undefined,
+  classId: string
+) {
+  const folder = await findFolderById(folderId);
+  if (!folder) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Folder not found",
+    });
+  }
+
+  if (!name.trim()) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Folder name cannot be empty",
+    });
+  }
+
+  return updateFolder(folderId, {
+    name: name.trim(),
+    ...(color && { color }),
+  });
+}
+
+export async function getFolderParents(folderId: string) {
+  const parents: Awaited<ReturnType<typeof findFolderByIdForTraversal>>[] = [];
+  let currentId: string | null = folderId;
+
+  while (currentId) {
+    const folder = await findFolderByIdForTraversal(currentId);
+    if (!folder) break;
+    parents.push(folder);
+    currentId = folder.parentFolderId;
+  }
+
+  return parents;
+}
+
+export async function getFolderUploadUrls(
+  userId: string,
+  classId: string,
+  folderId: string,
+  files: { name: string; type: string; size: number }[]
+) {
+  const classData = await findClassWithTeacher(classId, userId);
+  if (!classData) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Class not found or you are not a teacher",
+    });
+  }
+
+  const folder = await findFolderById(folderId);
+  if (!folder) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Folder not found",
+    });
+  }
+
+  let currentFolder: typeof folder | null = folder;
+  let belongsToClass = false;
+  while (currentFolder) {
+    if (currentFolder.classId === classId) {
+      belongsToClass = true;
+      break;
+    }
+    if (currentFolder.parentFolderId) {
+      currentFolder = await findFolderByIdForTraversal(currentFolder.parentFolderId);
+    } else {
+      break;
+    }
+  }
+
+  if (!belongsToClass) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Folder does not belong to this class",
+    });
+  }
+
+  return createDirectUploadFiles(files, userId, folderId);
+}

package/src/services/labChat.ts

@@ -0,0 +1,352 @@
+/**
+ * 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 { 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",
+    });
+  }
+
+  return labChat;
+}
+
+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)) {
+    generateAndSendLabResponse(
+      labChatId,
+      content,
+      labChat.conversationId
+    );
+  }
+
+  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 };
+}

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 };
+}