@studious-lms/server 1.6.0 → 1.8.0

package/src/services/class.ts

@@ -71,6 +71,9 @@ export async function getAllClasses(userId: string) {
       assignments: cls.assignments,
       members: [...cls.students, ...cls.teachers],
       color: cls.color,
+      schoolId: cls.schoolId ?? null,
+      school: cls.school ?? null,
+      department: cls.department ?? null,
     })),
     studentInClass: studentClasses.map((cls) => ({
       id: cls.id,
@@ -81,6 +84,9 @@ export async function getAllClasses(userId: string) {
       assignments: cls.assignments,
       members: [...cls.students, ...cls.teachers],
       color: cls.color,
+      schoolId: cls.schoolId ?? null,
+      school: cls.school ?? null,
+      department: cls.department ?? null,
     })),
   };
 }
@@ -112,20 +118,87 @@ export async function getClass(userId: string, classId: string) {
     })),
   };
 
-  const sections = await findSectionsByClassId(classId);
+  const [sections, affiliation] = await Promise.all([
+    findSectionsByClassId(classId),
+    prisma.class.findUnique({
+      where: { id: classId },
+      select: {
+        schoolId: true,
+        departmentId: true,
+        school: {
+          select: {
+            id: true,
+            name: true,
+            description: true,
+            logo: { select: { id: true, path: true, type: true } },
+          },
+        },
+        department: {
+          select: {
+            id: true,
+            name: true,
+            color: true,
+            description: true,
+          },
+        },
+        tags: {
+          select: { id: true, name: true, color: true, departmentId: true },
+        },
+      },
+    }),
+  ]);
 
   return {
     class: {
       ...formattedClassData,
       sections,
+      affiliation: affiliation
+        ? {
+            school: affiliation.school,
+            department: affiliation.department,
+            tags: affiliation.tags,
+          }
+        : null,
     },
   };
 }
 
 export async function updateClass(
   classId: string,
-  data: { name?: string; section?: string; subject?: string }
+  data: {
+    name?: string;
+    section?: string;
+    subject?: string;
+    color?: string;
+    departmentId?: string | null;
+  }
 ) {
+  if (data.departmentId !== undefined) {
+    // Department must belong to the class's institution.
+    const cls = await prisma.class.findUnique({
+      where: { id: classId },
+      select: { schoolId: true },
+    });
+    if (!cls?.schoolId && data.departmentId) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Personal classes can't have a department",
+      });
+    }
+    if (data.departmentId && cls?.schoolId) {
+      const dept = await prisma.department.findUnique({
+        where: { id: data.departmentId },
+        select: { schoolId: true },
+      });
+      if (!dept || dept.schoolId !== cls.schoolId) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "Department does not belong to this institution",
+        });
+      }
+    }
+  }
+
   const updatedClass = await prisma.class.update({
     where: { id: classId },
     data,
@@ -134,6 +207,8 @@ export async function updateClass(
       name: true,
       section: true,
       subject: true,
+      color: true,
+      departmentId: true,
     },
   });
   return { updatedClass };
@@ -149,9 +224,19 @@ export async function createClass(
     subject: string;
     color?: string;
     schoolId?: string;
+    departmentId?: string;
   }
 ) {
-  const { students, teachers, name, section, subject, color, schoolId } = input;
+  const {
+    students,
+    teachers,
+    name,
+    section,
+    subject,
+    color,
+    schoolId,
+    departmentId,
+  } = input;
 
   if (schoolId) {
     const membership = await prisma.schoolMembership.findFirst({
@@ -174,6 +259,25 @@ export async function createClass(
     }
   }
 
+  if (departmentId) {
+    if (!schoolId) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Personal classes can't have a department",
+      });
+    }
+    const dept = await prisma.department.findUnique({
+      where: { id: departmentId },
+      select: { schoolId: true },
+    });
+    if (!dept || dept.schoolId !== schoolId) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Department does not belong to this institution",
+      });
+    }
+  }
+
   const teacherIds = teachers?.length ? teachers : [userId];
   const studentIds = students?.length ? students : [];
 
@@ -188,6 +292,7 @@ export async function createClass(
       subject,
       color,
       schoolId,
+      departmentId,
       teachers: { connect: teacherIds.map((id) => ({ id })) },
       ...(studentIds.length
         ? { students: { connect: studentIds.map((id) => ({ id })) } }

package/src/services/conversation.ts

@@ -8,6 +8,7 @@ import {
   countUnreadMessages,
   countUnreadMentions,
   findUserByUsername,
+  searchInstitutionConversationMembers,
   findDmConversationsByUserId,
   findUsersByIdsOrUsernames,
   createConversation,
@@ -17,6 +18,11 @@ import {
   deleteConversationMember,
 } from "../models/conversation.js";
 
+/** Maximum number of member suggestions returned for conversation search. */
+const MAX_MEMBER_SEARCH_RESULTS = 10;
+/** Minimum non-whitespace characters required before running member search. */
+const MIN_MEMBER_SEARCH_QUERY_LENGTH = 2;
+
 /** List user's conversations with unread and mention counts. */
 export async function listConversations(userId: string) {
   const conversations = await findConversationsByUserId(userId);
@@ -89,6 +95,30 @@ export async function hideConversation(userId: string, conversationId: string) {
   return { success: true };
 }
 
+/**
+ * Search active school peers that can be selected for a new conversation.
+ *
+ * Blank or one-character input returns an empty list instead of searching all
+ * institution members, which keeps typeahead callers from issuing broad result
+ * queries.
+ */
+export async function searchConversationMembers(userId: string, query: string) {
+  const trimmedQuery = query.trim();
+
+  if (
+    !trimmedQuery ||
+    trimmedQuery.length < MIN_MEMBER_SEARCH_QUERY_LENGTH
+  ) {
+    return [];
+  }
+
+  return searchInstitutionConversationMembers(
+    userId,
+    trimmedQuery,
+    MAX_MEMBER_SEARCH_RESULTS
+  );
+}
+
 /** Create a DM or group conversation with the given members. */
 export async function createConversationRecord(
   userId: string,

package/src/services/department.ts

@@ -0,0 +1,478 @@
+/**
+ * Department service — admin CRUD, members, and template management for
+ * department-level rubrics and grading boundaries.
+ */
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import {
+  addDepartmentMembers,
+  createDepartment,
+  deleteDepartment,
+  findDepartmentMembership,
+  getDepartment,
+  listDepartmentsForSchool,
+  listDepartmentsForUser,
+  removeDepartmentMember,
+  updateDepartment,
+} from "../models/department.js";
+import {
+  findActiveSchoolAdminMembership,
+  findSchoolMembership,
+} from "../models/school.js";
+
+async function requireAdmin(schoolId: string, userId: string) {
+  const membership = await findActiveSchoolAdminMembership(schoolId, userId);
+  if (!membership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only school admins can manage departments",
+    });
+  }
+}
+
+async function requireMember(schoolId: string, userId: string) {
+  const membership = await findSchoolMembership(schoolId, userId);
+  if (!membership || membership.status !== "ACTIVE") {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You aren't a member of this institution",
+    });
+  }
+}
+
+export async function listDepartments(
+  userId: string,
+  schoolId: string
+) {
+  await requireMember(schoolId, userId);
+  return listDepartmentsForSchool(schoolId);
+}
+
+export async function listMyDepartments(
+  userId: string,
+  schoolId: string
+) {
+  await requireMember(schoolId, userId);
+  return listDepartmentsForUser(userId, schoolId);
+}
+
+export async function getDepartmentDetails(
+  userId: string,
+  departmentId: string
+) {
+  const department = await getDepartment(departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireMember(department.schoolId, userId);
+  return department;
+}
+
+export async function createDepartmentRecord(
+  userId: string,
+  input: {
+    schoolId: string;
+    name: string;
+    description?: string;
+    color?: string;
+  }
+) {
+  await requireAdmin(input.schoolId, userId);
+  return createDepartment(input);
+}
+
+export async function updateDepartmentRecord(
+  userId: string,
+  input: {
+    departmentId: string;
+    name?: string;
+    description?: string | null;
+    color?: string;
+  }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  return updateDepartment(input.departmentId, {
+    name: input.name,
+    description: input.description,
+    color: input.color,
+  });
+}
+
+export async function deleteDepartmentRecord(
+  userId: string,
+  departmentId: string
+) {
+  const department = await getDepartment(departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  await deleteDepartment(departmentId);
+  return { success: true };
+}
+
+export async function addMembersToDepartment(
+  userId: string,
+  input: { departmentId: string; userIds: string[] }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+
+  // Members must already be in the institution.
+  const memberships = await prisma.schoolMembership.findMany({
+    where: {
+      schoolId: department.schoolId,
+      userId: { in: input.userIds },
+      status: "ACTIVE",
+    },
+    select: { userId: true },
+  });
+  const validIds = new Set(memberships.map((m) => m.userId));
+  const validUserIds = input.userIds.filter((id) => validIds.has(id));
+
+  if (validUserIds.length === 0) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "None of the supplied users are institution members",
+    });
+  }
+  return addDepartmentMembers(input.departmentId, validUserIds);
+}
+
+export async function removeMemberFromDepartment(
+  userId: string,
+  input: { departmentId: string; memberId: string }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  return removeDepartmentMember(input.departmentId, input.memberId);
+}
+
+/** Department template authoring (rubrics + boundaries). */
+export async function createRubricTemplate(
+  userId: string,
+  input: { departmentId: string; name: string; structured: string }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  return prisma.markScheme.create({
+    data: {
+      name: input.name,
+      structured: input.structured.replace(/\\n/g, "\n"),
+      department: { connect: { id: input.departmentId } },
+    },
+    select: { id: true, name: true, structured: true, departmentId: true },
+  });
+}
+
+export async function updateRubricTemplate(
+  userId: string,
+  input: {
+    templateId: string;
+    name?: string;
+    structured?: string;
+  }
+) {
+  const template = await prisma.markScheme.findUnique({
+    where: { id: input.templateId },
+    select: { departmentId: true, department: { select: { schoolId: true } } },
+  });
+  if (!template?.departmentId || !template.department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  await requireAdmin(template.department.schoolId, userId);
+  return prisma.markScheme.update({
+    where: { id: input.templateId },
+    data: {
+      ...(input.name !== undefined ? { name: input.name } : {}),
+      ...(input.structured !== undefined
+        ? { structured: input.structured.replace(/\\n/g, "\n") }
+        : {}),
+    },
+  });
+}
+
+export async function deleteRubricTemplate(
+  userId: string,
+  templateId: string
+) {
+  const template = await prisma.markScheme.findUnique({
+    where: { id: templateId },
+    select: { departmentId: true, department: { select: { schoolId: true } } },
+  });
+  if (!template?.departmentId || !template.department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  await requireAdmin(template.department.schoolId, userId);
+  return prisma.markScheme.delete({ where: { id: templateId } });
+}
+
+export async function createBoundaryTemplate(
+  userId: string,
+  input: { departmentId: string; name: string; structured: string }
+) {
+  const department = await getDepartment(input.departmentId);
+  if (!department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Department not found",
+    });
+  }
+  await requireAdmin(department.schoolId, userId);
+  return prisma.gradingBoundary.create({
+    data: {
+      name: input.name,
+      structured: input.structured.replace(/\\n/g, "\n"),
+      department: { connect: { id: input.departmentId } },
+    },
+    select: { id: true, name: true, structured: true, departmentId: true },
+  });
+}
+
+export async function updateBoundaryTemplate(
+  userId: string,
+  input: {
+    templateId: string;
+    name?: string;
+    structured?: string;
+  }
+) {
+  const template = await prisma.gradingBoundary.findUnique({
+    where: { id: input.templateId },
+    select: { departmentId: true, department: { select: { schoolId: true } } },
+  });
+  if (!template?.departmentId || !template.department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  await requireAdmin(template.department.schoolId, userId);
+  return prisma.gradingBoundary.update({
+    where: { id: input.templateId },
+    data: {
+      ...(input.name !== undefined ? { name: input.name } : {}),
+      ...(input.structured !== undefined
+        ? { structured: input.structured.replace(/\\n/g, "\n") }
+        : {}),
+    },
+  });
+}
+
+export async function deleteBoundaryTemplate(
+  userId: string,
+  templateId: string
+) {
+  const template = await prisma.gradingBoundary.findUnique({
+    where: { id: templateId },
+    select: { departmentId: true, department: { select: { schoolId: true } } },
+  });
+  if (!template?.departmentId || !template.department) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  await requireAdmin(template.department.schoolId, userId);
+  return prisma.gradingBoundary.delete({ where: { id: templateId } });
+}
+
+/**
+ * Apply a department template to a class by *copying* the structured payload
+ * into a class-scoped record. Teacher-only (the class teacher).
+ */
+export async function applyRubricTemplate(
+  userId: string,
+  input: { classId: string; templateId: string }
+) {
+  const cls = await prisma.class.findFirst({
+    where: {
+      id: input.classId,
+      OR: [
+        { teachers: { some: { id: userId } } },
+        {
+          school: {
+            memberships: {
+              some: { userId, role: "ADMIN", status: "ACTIVE" },
+            },
+          },
+        },
+      ],
+    },
+    select: { id: true, departmentId: true },
+  });
+  if (!cls) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You don't have permission to apply templates to this class",
+    });
+  }
+
+  const template = await prisma.markScheme.findUnique({
+    where: { id: input.templateId },
+    select: { id: true, structured: true, departmentId: true, name: true },
+  });
+  if (!template?.departmentId) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  if (cls.departmentId && cls.departmentId !== template.departmentId) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message:
+        "This template belongs to a different department than the class",
+    });
+  }
+
+  return prisma.markScheme.create({
+    data: {
+      class: { connect: { id: input.classId } },
+      structured: template.structured,
+      name: template.name,
+    },
+  });
+}
+
+export async function applyBoundaryTemplate(
+  userId: string,
+  input: { classId: string; templateId: string }
+) {
+  const cls = await prisma.class.findFirst({
+    where: {
+      id: input.classId,
+      OR: [
+        { teachers: { some: { id: userId } } },
+        {
+          school: {
+            memberships: {
+              some: { userId, role: "ADMIN", status: "ACTIVE" },
+            },
+          },
+        },
+      ],
+    },
+    select: { id: true, departmentId: true },
+  });
+  if (!cls) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You don't have permission to apply templates to this class",
+    });
+  }
+
+  const template = await prisma.gradingBoundary.findUnique({
+    where: { id: input.templateId },
+    select: { id: true, structured: true, departmentId: true, name: true },
+  });
+  if (!template?.departmentId) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Template not found",
+    });
+  }
+  if (cls.departmentId && cls.departmentId !== template.departmentId) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message:
+        "This template belongs to a different department than the class",
+    });
+  }
+
+  return prisma.gradingBoundary.create({
+    data: {
+      class: { connect: { id: input.classId } },
+      structured: template.structured,
+      name: template.name,
+    },
+  });
+}
+
+/** Helper used by the auto-tag flow on class creation. */
+export async function setClassDepartment(
+  userId: string,
+  input: { classId: string; departmentId: string | null }
+) {
+  const cls = await prisma.class.findFirst({
+    where: {
+      id: input.classId,
+      OR: [
+        { teachers: { some: { id: userId } } },
+        {
+          school: {
+            memberships: {
+              some: { userId, role: "ADMIN", status: "ACTIVE" },
+            },
+          },
+        },
+      ],
+    },
+    select: { id: true, schoolId: true },
+  });
+  if (!cls?.schoolId) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Class is not affiliated with an institution",
+    });
+  }
+
+  if (input.departmentId) {
+    const dept = await getDepartment(input.departmentId);
+    if (!dept || dept.schoolId !== cls.schoolId) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Department does not belong to this institution",
+      });
+    }
+  }
+  return prisma.class.update({
+    where: { id: input.classId },
+    data: { departmentId: input.departmentId },
+    select: { id: true, departmentId: true },
+  });
+}
+
+export async function checkDepartmentMember(
+  userId: string,
+  departmentId: string
+) {
+  return Boolean(await findDepartmentMembership(departmentId, userId));
+}