@studious-lms/server 1.7.0 → 1.9.0

package/src/routers/school.ts

@@ -7,18 +7,24 @@ import {
 import {
   acceptInvite,
   addMember,
+  confirmSchoolAssetUpload,
   createInvite,
   createSchoolClass,
   createSchoolRecord,
   getAdminOverview,
   getCurrentSchool,
   getInvite,
+  getSchoolAssetUploadUrl,
+  getStudentTimeline,
   listClasses,
   listInvites,
+  listMemberIds,
   listMembers,
   removeMember,
   revokeInvite,
+  searchMembers,
   updateMemberRole,
+  updateSchoolDetails,
 } from "../services/school.js";
 
 const schoolRoleSchema = z.enum(["ADMIN", "TEACHER", "STUDENT"]);
@@ -38,12 +44,88 @@ export const schoolRouter = createTRPCRouter({
     .input(
       z.object({
         name: z.string().min(1),
+        description: z.string().optional(),
         subdomain: z.string().min(1).optional(),
         logoId: z.string().optional(),
       })
     )
     .mutation(({ ctx, input }) => createSchoolRecord(ctx.user!.id, input)),
 
+  update: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        name: z.string().min(1).optional(),
+        description: z.string().nullable().optional(),
+        subdomain: z.string().nullable().optional(),
+        logoId: z.string().nullable().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateSchoolDetails(ctx.user!.id, input)),
+
+  searchMembers: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        query: z.string(),
+        limit: z.number().min(1).max(50).optional(),
+        role: schoolRoleSchema.optional(),
+      })
+    )
+    .query(({ ctx, input }) =>
+      searchMembers(
+        ctx.user!.id,
+        input.schoolId,
+        input.query,
+        input.limit,
+        input.role
+      )
+    ),
+
+  listMemberIds: protectedProcedure
+    .input(schoolIdSchema)
+    .query(({ ctx, input }) => listMemberIds(ctx.user!.id, input.schoolId)),
+
+  getAssetUploadUrl: protectedProcedure
+    .input(
+      z.object({
+        fileName: z.string(),
+        fileType: z.string(),
+        fileSize: z.number(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      getSchoolAssetUploadUrl(ctx.user!.id, input)
+    ),
+
+  confirmAssetUpload: protectedProcedure
+    .input(
+      z.object({
+        fileId: z.string(),
+        uploadSuccess: z.boolean(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      confirmSchoolAssetUpload(
+        ctx.user!.id,
+        input.fileId,
+        input.uploadSuccess
+      )
+    ),
+
+  getStudentTimeline: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        studentId: z.string(),
+        from: z.date().optional(),
+        to: z.date().optional(),
+      })
+    )
+    .query(({ ctx, input }) =>
+      getStudentTimeline(ctx.user!.id, input)
+    ),
+
   getAdminOverview: protectedProcedure
     .input(schoolIdSchema)
     .query(({ ctx, input }) => getAdminOverview(ctx.user!.id, input.schoolId)),
@@ -60,6 +142,7 @@ export const schoolRouter = createTRPCRouter({
         section: z.string(),
         subject: z.string(),
         color: z.string().optional(),
+        departmentId: z.string().optional(),
         teachers: z.array(z.string()).optional(),
         students: z.array(z.string()).optional(),
       })

package/src/routers/tag.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import {
+  attachTag,
+  createTagRecord,
+  deleteTagRecord,
+  detachTag,
+  getAttachedTags,
+  listTags,
+  updateTagRecord,
+} from "../services/tag.js";
+
+const tagTargetSchema = z.enum(["USER", "CLASS", "RUBRIC", "BOUNDARY"]);
+
+export const tagRouter = createTRPCRouter({
+  list: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        departmentId: z.string().nullable().optional(),
+      })
+    )
+    .query(({ ctx, input }) => listTags(ctx.user!.id, input)),
+
+  create: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        departmentId: z.string().nullable().optional(),
+        name: z.string().min(1),
+        color: z.string().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createTagRecord(ctx.user!.id, input)),
+
+  update: protectedProcedure
+    .input(
+      z.object({
+        tagId: z.string(),
+        name: z.string().min(1).optional(),
+        color: z.string().optional(),
+        departmentId: z.string().nullable().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateTagRecord(ctx.user!.id, input)),
+
+  delete: protectedProcedure
+    .input(z.object({ tagId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      deleteTagRecord(ctx.user!.id, input.tagId)
+    ),
+
+  attach: protectedProcedure
+    .input(
+      z.object({
+        tagId: z.string(),
+        target: tagTargetSchema,
+        targetId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) => attachTag(ctx.user!.id, input)),
+
+  detach: protectedProcedure
+    .input(
+      z.object({
+        tagId: z.string(),
+        target: tagTargetSchema,
+        targetId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) => detachTag(ctx.user!.id, input)),
+
+  getAttached: protectedProcedure
+    .input(
+      z.object({ target: tagTargetSchema, targetId: z.string() })
+    )
+    .query(({ ctx, input }) => getAttachedTags(ctx.user!.id, input)),
+});

package/src/services/class.ts

@@ -71,7 +71,10 @@ 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,
+    })).filter((cls) => cls.members.some((member) => member.id === userId)),
     studentInClass: studentClasses.map((cls) => ({
       id: cls.id,
       name: cls.name,
@@ -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 })) } }