@studious-lms/server 1.21.0 → 1.23.0

package/src/models/school.ts

@@ -176,6 +176,95 @@ export function getSchoolOverview(schoolId: string) {
   });
 }
 
+export function listRecentSchoolMembers(schoolId: string, take = 5) {
+  return prisma.schoolMembership.findMany({
+    where: { schoolId, status: "ACTIVE" },
+    select: memberSelect,
+    orderBy: { createdAt: "desc" },
+    take,
+  });
+}
+
+export function getSchoolMemberDetail(schoolId: string, memberUserId: string) {
+  return prisma.schoolMembership.findUnique({
+    where: { schoolId_userId: { schoolId, userId: memberUserId } },
+    select: memberSelect,
+  });
+}
+
+const memberClassSelect = {
+  id: true,
+  name: true,
+  section: true,
+  subject: true,
+  color: true,
+  _count: { select: { teachers: true, students: true } },
+} as const;
+
+export function listMemberClasses(schoolId: string, memberUserId: string) {
+  return prisma.$transaction([
+    prisma.class.findMany({
+      where: { schoolId, teachers: { some: { id: memberUserId } } },
+      select: memberClassSelect,
+      orderBy: { name: "asc" },
+    }),
+    prisma.class.findMany({
+      where: { schoolId, students: { some: { id: memberUserId } } },
+      select: memberClassSelect,
+      orderBy: { name: "asc" },
+    }),
+  ]);
+}
+
+export function findSchoolClass(schoolId: string, classId: string) {
+  return prisma.class.findFirst({
+    where: { id: classId, schoolId },
+    select: { id: true, name: true },
+  });
+}
+
+export function deleteSchoolClassRecord(schoolId: string, classId: string) {
+  return prisma.class.delete({
+    where: { id: classId, schoolId },
+    select: { id: true },
+  });
+}
+
+export function updateSchoolClassMembers(
+  classId: string,
+  data: {
+    addTeacherIds: string[];
+    removeTeacherIds: string[];
+    addStudentIds: string[];
+    removeStudentIds: string[];
+  }
+) {
+  return prisma.class.update({
+    where: { id: classId },
+    data: {
+      teachers: {
+        connect: data.addTeacherIds.map((id) => ({ id })),
+        disconnect: data.removeTeacherIds.map((id) => ({ id })),
+      },
+      students: {
+        connect: data.addStudentIds.map((id) => ({ id })),
+        disconnect: data.removeStudentIds.map((id) => ({ id })),
+      },
+    },
+    select: {
+      id: true,
+      _count: { select: { teachers: true, students: true } },
+    },
+  });
+}
+
+export function listActiveSchoolMemberships(schoolId: string, userIds: string[]) {
+  return prisma.schoolMembership.findMany({
+    where: { schoolId, userId: { in: userIds }, status: "ACTIVE" },
+    select: { userId: true, role: true, status: true },
+  });
+}
+
 export function listSchoolClasses(schoolId: string) {
   return prisma.class.findMany({
     where: { schoolId },

package/src/routers/_app.ts

@@ -29,6 +29,7 @@ import { permissionsRouter } from "./permissions.js";
 import { discussionRouter } from "./discussion.js";
 import { adminRouter } from "./admin.js";
 import { embeddingRouter } from "./embedding.js";
+import { gradebookRouter } from "./gradebook.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -59,6 +60,7 @@ export const appRouter = createTRPCRouter({
   discussion: discussionRouter,
   admin: adminRouter,
   embedding: embeddingRouter,
+  gradebook: gradebookRouter,
 });
 
 // Export type router type definition

package/src/routers/admin.ts

@@ -4,15 +4,21 @@ import { createTRPCRouter, adminProcedure } from '../trpc.js';
 import {
   getRunJobForAdmin,
   listRunJobsForAdmin,
+  retryRunJobForAdmin,
 } from '../services/adminRunJob.js';
 import {
+  getSchoolForAdmin,
   listDepartmentsForAdmin,
   listEarlyAccessRequestsForAdmin,
   listSchoolDevelopmentProgramsForAdmin,
   listSchoolsForAdmin,
 } from '../services/adminInstitution.js';
+import { getOverviewMetricsForAdmin } from '../services/adminMetrics.js';
+import { getUserForAdmin, searchUsersForAdmin } from '../services/adminUser.js';
 
 export const adminRouter = createTRPCRouter({
+  getOverviewMetrics: adminProcedure.query(() => getOverviewMetricsForAdmin()),
+
   listRunJobs: adminProcedure
     .input(
       z.object({
@@ -28,6 +34,14 @@ export const adminRouter = createTRPCRouter({
     .input(z.object({ id: z.string().uuid() }))
     .query(({ input }) => getRunJobForAdmin(input.id)),
 
+  retryRunJob: adminProcedure
+    .input(z.object({ id: z.string().uuid() }))
+    .mutation(({ input }) => retryRunJobForAdmin(input.id)),
+
+  getSchool: adminProcedure
+    .input(z.object({ id: z.string().uuid() }))
+    .query(({ input }) => getSchoolForAdmin(input.id)),
+
   listSchools: adminProcedure
     .input(
       z.object({
@@ -67,4 +81,18 @@ export const adminRouter = createTRPCRouter({
       }),
     )
     .query(({ input }) => listEarlyAccessRequestsForAdmin(input)),
+
+  searchUsers: adminProcedure
+    .input(
+      z.object({
+        page: z.number().int().min(0).default(0),
+        pageSize: z.number().int().min(1).max(100).default(25),
+        query: z.string().optional(),
+      }),
+    )
+    .query(({ input }) => searchUsersForAdmin(input)),
+
+  getUser: adminProcedure
+    .input(z.object({ id: z.string().uuid() }))
+    .query(({ input }) => getUserForAdmin(input.id)),
 });

package/src/routers/file.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
+import { TRPCError } from "@trpc/server";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { prisma } from "../lib/prisma.js";
 import {
   deleteFileGeneric,
   getFileSignedUrl,
@@ -7,6 +9,31 @@ import {
   renameFileScoped,
 } from "../services/file.js";
 
+const upsertAnnotationSchema = z.object({
+  fileId: z.string(),
+  id: z.string().optional(),
+  page: z.number().int().min(1),
+  type: z.enum(["HIGHLIGHT", "INK", "COMMENT", "TEXT"]),
+  geometry: z.record(z.string(), z.unknown()),
+  text: z.string().optional(),
+  color: z.string().optional(),
+});
+
+/** @throws NOT_FOUND unless the file exists and is owned by the user. */
+async function requireOwnedFile(userId: string, fileId: string) {
+  const file = await prisma.file.findFirst({
+    where: { id: fileId, userId },
+    select: { id: true },
+  });
+
+  if (!file) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "File not found or you don't own it",
+    });
+  }
+}
+
 /**
  * File router. Backed by the same unified scope-aware permission model as the
  * folder router. The class files page and the cloud-storage page (personal /
@@ -55,4 +82,105 @@ export const fileRouter = createTRPCRouter({
     .mutation(({ ctx, input }) =>
       deleteFileGeneric(ctx.user!.id, input.fileId)
     ),
+
+  // PDF annotations on files the user owns (personal cloud storage). The
+  // submission review flow uses the annotation endpoints on the assignment
+  // router instead; these are owner-only and carry no submission context.
+  listAnnotations: protectedProcedure
+    .input(z.object({ fileId: z.string() }))
+    .query(async ({ ctx, input }) => {
+      await requireOwnedFile(ctx.user!.id, input.fileId);
+
+      const annotations = await prisma.fileAnnotation.findMany({
+        where: { fileId: input.fileId, submissionId: null },
+        orderBy: { createdAt: "asc" },
+        include: {
+          author: {
+            select: {
+              id: true,
+              username: true,
+              profile: { select: { displayName: true } },
+            },
+          },
+        },
+      });
+
+      return { annotations };
+    }),
+
+  upsertAnnotation: protectedProcedure
+    .input(upsertAnnotationSchema)
+    .mutation(async ({ ctx, input }) => {
+      const { fileId, id, page, type, geometry, text, color } = input;
+
+      await requireOwnedFile(ctx.user!.id, fileId);
+
+      if (id) {
+        const existing = await prisma.fileAnnotation.findFirst({
+          where: { id, fileId, submissionId: null, authorId: ctx.user!.id },
+          select: { id: true },
+        });
+
+        if (!existing) {
+          throw new TRPCError({
+            code: "NOT_FOUND",
+            message: "Annotation not found",
+          });
+        }
+
+        const annotation = await prisma.fileAnnotation.update({
+          where: { id },
+          data: {
+            page,
+            type,
+            geometry: geometry as object,
+            text: text ?? null,
+            color: color ?? null,
+          },
+        });
+
+        return { annotation };
+      }
+
+      const annotation = await prisma.fileAnnotation.create({
+        data: {
+          fileId,
+          authorId: ctx.user!.id,
+          page,
+          type,
+          geometry: geometry as object,
+          text: text ?? null,
+          color: color ?? null,
+        },
+      });
+
+      return { annotation };
+    }),
+
+  deleteAnnotation: protectedProcedure
+    .input(z.object({ fileId: z.string(), id: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      await requireOwnedFile(ctx.user!.id, input.fileId);
+
+      const annotation = await prisma.fileAnnotation.findFirst({
+        where: {
+          id: input.id,
+          fileId: input.fileId,
+          submissionId: null,
+          authorId: ctx.user!.id,
+        },
+        select: { id: true },
+      });
+
+      if (!annotation) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Annotation not found",
+        });
+      }
+
+      await prisma.fileAnnotation.delete({ where: { id: input.id } });
+
+      return { success: true };
+    }),
 });

package/src/routers/gradebook.ts

@@ -0,0 +1,173 @@
+import { z } from "zod";
+import {
+  createTRPCRouter,
+  protectedTeacherProcedure,
+  protectedClassMemberProcedure,
+} from "../trpc.js";
+import {
+  listGradeCategories,
+  createGradeCategory,
+  updateGradeCategory,
+  deleteGradeCategory,
+  assignAssignmentCategory,
+  listCustomGradeColumns,
+  createCustomGradeColumn,
+  updateCustomGradeColumn,
+  deleteCustomGradeColumn,
+  setCustomGradeEntry,
+  getGradePolicies,
+  updateGradePolicies,
+  getComputedGradebook,
+  exportGradebookCsv,
+} from "../services/gradebook.js";
+
+const roundingModeSchema = z.enum(["NONE", "HALF_UP", "FLOOR", "CEILING"]);
+
+export const gradebookRouter = createTRPCRouter({
+  listCategories: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => listGradeCategories(input.classId)),
+
+  createCategory: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        name: z.string().min(1),
+        weight: z.number().min(0),
+        dropLowest: z.number().int().min(0).optional(),
+        position: z.number().int().min(0).optional(),
+      })
+    )
+    .mutation(({ input }) => {
+      const { classId, ...data } = input;
+      return createGradeCategory(classId, data);
+    }),
+
+  updateCategory: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        categoryId: z.string(),
+        name: z.string().min(1).optional(),
+        weight: z.number().min(0).optional(),
+        dropLowest: z.number().int().min(0).optional(),
+        position: z.number().int().min(0).optional(),
+      })
+    )
+    .mutation(({ input }) => {
+      const { classId, categoryId, ...data } = input;
+      return updateGradeCategory(categoryId, classId, data);
+    }),
+
+  deleteCategory: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), categoryId: z.string() }))
+    .mutation(({ input }) =>
+      deleteGradeCategory(input.categoryId, input.classId)
+    ),
+
+  assignCategory: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        assignmentId: z.string(),
+        gradeCategoryId: z.string().nullable(),
+      })
+    )
+    .mutation(({ input }) =>
+      assignAssignmentCategory(
+        input.classId,
+        input.assignmentId,
+        input.gradeCategoryId
+      )
+    ),
+
+  listColumns: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => listCustomGradeColumns(input.classId)),
+
+  createColumn: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        name: z.string().min(1),
+        maxPoints: z.number().positive(),
+        gradeCategoryId: z.string().nullable().optional(),
+        position: z.number().int().min(0).optional(),
+      })
+    )
+    .mutation(({ input }) => {
+      const { classId, ...data } = input;
+      return createCustomGradeColumn(classId, data);
+    }),
+
+  updateColumn: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        columnId: z.string(),
+        name: z.string().min(1).optional(),
+        maxPoints: z.number().positive().optional(),
+        gradeCategoryId: z.string().nullable().optional(),
+        position: z.number().int().min(0).optional(),
+      })
+    )
+    .mutation(({ input }) => {
+      const { classId, columnId, ...data } = input;
+      return updateCustomGradeColumn(columnId, classId, data);
+    }),
+
+  deleteColumn: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), columnId: z.string() }))
+    .mutation(({ input }) =>
+      deleteCustomGradeColumn(input.columnId, input.classId)
+    ),
+
+  setEntry: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        columnId: z.string(),
+        studentId: z.string(),
+        points: z.number().min(0).nullable(),
+        note: z.string().nullable().optional(),
+      })
+    )
+    .mutation(({ input }) =>
+      setCustomGradeEntry(
+        input.classId,
+        input.columnId,
+        input.studentId,
+        input.points,
+        input.note
+      )
+    ),
+
+  getPolicies: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ input }) => getGradePolicies(input.classId)),
+
+  updatePolicies: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        treatMissingAsZero: z.boolean().optional(),
+        gradeRoundingMode: roundingModeSchema.optional(),
+      })
+    )
+    .mutation(({ input }) => {
+      const { classId, ...data } = input;
+      return updateGradePolicies(classId, data);
+    }),
+
+  getComputed: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) =>
+      getComputedGradebook(input.classId, ctx.user?.id ?? "")
+    ),
+
+  exportCsv: protectedTeacherProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) =>
+      exportGradebookCsv(input.classId, ctx.user?.id ?? "")
+    ),
+});

package/src/routers/school.ts

@@ -7,13 +7,17 @@ import {
 import {
   acceptInvite,
   addMember,
+  bulkRemoveMembers,
+  bulkUpdateMemberRoles,
   confirmSchoolAssetUpload,
   createInvite,
   createSchoolClass,
   createSchoolRecord,
+  deleteSchoolClass,
   getAdminOverview,
   getCurrentSchool,
   getInvite,
+  getMemberDetail,
   getMemberTimeline,
   getSchoolAssetUploadUrl,
   getStudentTimeline,
@@ -24,6 +28,7 @@ import {
   removeMember,
   revokeInvite,
   searchMembers,
+  updateClassMembers,
   updateMemberRole,
   updateSchoolDetails,
 } from "../services/school.js";
@@ -174,6 +179,23 @@ export const schoolRouter = createTRPCRouter({
     )
     .mutation(({ ctx, input }) => createSchoolClass(ctx.user!.id, input)),
 
+  deleteClass: protectedProcedure
+    .input(z.object({ schoolId: z.string(), classId: z.string() }))
+    .mutation(({ ctx, input }) => deleteSchoolClass(ctx.user!.id, input)),
+
+  updateClassMembers: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        classId: z.string(),
+        addTeacherIds: z.array(z.string()).optional(),
+        removeTeacherIds: z.array(z.string()).optional(),
+        addStudentIds: z.array(z.string()).optional(),
+        removeStudentIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateClassMembers(ctx.user!.id, input)),
+
   listMembers: protectedProcedure
     .input(schoolIdSchema)
     .query(({ ctx, input }) => listMembers(ctx.user!.id, input.schoolId)),
@@ -202,6 +224,29 @@ export const schoolRouter = createTRPCRouter({
     .input(z.object({ schoolId: z.string(), memberUserId: z.string() }))
     .mutation(({ ctx, input }) => removeMember(ctx.user!.id, input)),
 
+  getMemberDetail: protectedProcedure
+    .input(z.object({ schoolId: z.string(), memberUserId: z.string() }))
+    .query(({ ctx, input }) => getMemberDetail(ctx.user!.id, input)),
+
+  bulkUpdateMemberRoles: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        memberUserIds: z.array(z.string()).min(1).max(200),
+        role: schoolRoleSchema,
+      })
+    )
+    .mutation(({ ctx, input }) => bulkUpdateMemberRoles(ctx.user!.id, input)),
+
+  bulkRemoveMembers: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        memberUserIds: z.array(z.string()).min(1).max(200),
+      })
+    )
+    .mutation(({ ctx, input }) => bulkRemoveMembers(ctx.user!.id, input)),
+
   listInvites: protectedProcedure
     .input(schoolIdSchema)
     .query(({ ctx, input }) => listInvites(ctx.user!.id, input.schoolId)),

package/src/services/adminInstitution.ts

@@ -1,4 +1,5 @@
 import type { Prisma } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
 import { prisma } from '../lib/prisma.js';
 
 export async function listSchoolsForAdmin(input: {
@@ -45,6 +46,57 @@ export async function listSchoolsForAdmin(input: {
   };
 }
 
+export async function getSchoolForAdmin(id: string) {
+  const school = await prisma.school.findUnique({
+    where: { id },
+    include: {
+      _count: {
+        select: { memberships: true, classes: true, departments: true },
+      },
+      memberships: {
+        orderBy: { createdAt: 'desc' },
+        take: 100,
+        select: {
+          id: true,
+          role: true,
+          status: true,
+          createdAt: true,
+          user: {
+            select: { id: true, username: true, email: true, verified: true },
+          },
+        },
+      },
+      classes: {
+        orderBy: { name: 'asc' },
+        take: 100,
+        select: {
+          id: true,
+          name: true,
+          subject: true,
+          section: true,
+          color: true,
+          department: { select: { id: true, name: true } },
+          _count: { select: { students: true, teachers: true } },
+        },
+      },
+      departments: {
+        orderBy: { name: 'asc' },
+        select: {
+          id: true,
+          name: true,
+          color: true,
+          _count: { select: { classes: true, members: true } },
+        },
+      },
+    },
+  });
+
+  if (!school) {
+    throw new TRPCError({ code: 'NOT_FOUND', message: 'School not found' });
+  }
+  return school;
+}
+
 export async function listDepartmentsForAdmin(input: {
   page: number;
   pageSize: number;

package/src/services/adminMetrics.ts

@@ -0,0 +1,46 @@
+import { prisma } from '../lib/prisma.js';
+
+export async function getOverviewMetricsForAdmin() {
+  const dayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+
+  const [
+    schools,
+    users,
+    verifiedUsers,
+    classes,
+    departments,
+    runJobsByStatus,
+    failedRunJobsLast24h,
+    earlyAccessRequests,
+    pendingDevProgramApplications,
+  ] = await Promise.all([
+    prisma.school.count(),
+    prisma.user.count(),
+    prisma.user.count({ where: { verified: true } }),
+    prisma.class.count(),
+    prisma.department.count(),
+    prisma.runJob.groupBy({ by: ['status'], _count: { _all: true } }),
+    prisma.runJob.count({
+      where: { status: 'FAILED', createdAt: { gte: dayAgo } },
+    }),
+    prisma.earlyAccessRequest.count(),
+    prisma.schoolDevelopementProgram.count({ where: { status: 'PENDING' } }),
+  ]);
+
+  return {
+    schools,
+    users,
+    verifiedUsers,
+    classes,
+    departments,
+    runJobs: {
+      byStatus: runJobsByStatus.map((row) => ({
+        status: row.status,
+        count: row._count._all,
+      })),
+      failedLast24h: failedRunJobsLast24h,
+    },
+    earlyAccessRequests,
+    pendingDevProgramApplications,
+  };
+}

package/src/services/adminRunJob.ts

@@ -1,6 +1,7 @@
 import type { Prisma, RunJobStatus, RunJobType } from '@prisma/client';
 import { TRPCError } from '@trpc/server';
 import { prisma } from '../lib/prisma.js';
+import { enqueueRunJob, type JobInputs } from '../workers/queues.js';
 
 export async function listRunJobsForAdmin(input: {
   page: number;
@@ -44,3 +45,26 @@ export async function getRunJobForAdmin(id: string) {
   }
   return job;
 }
+
+/**
+ * Re-enqueue a FAILED or CANCELLED job as a fresh RunJob row with the same
+ * type/input. The original row is left untouched for audit purposes.
+ */
+export async function retryRunJobForAdmin(id: string) {
+  const job = await getRunJobForAdmin(id);
+
+  if (job.status !== 'FAILED' && job.status !== 'CANCELLED') {
+    throw new TRPCError({
+      code: 'PRECONDITION_FAILED',
+      message: `Only FAILED or CANCELLED jobs can be retried (status: ${job.status})`,
+    });
+  }
+
+  const { runJobId, bullJobId } = await enqueueRunJob(
+    job.type,
+    job.input as JobInputs[typeof job.type],
+    { classId: job.classId, userId: job.userId },
+  );
+
+  return { runJobId, bullJobId, retriedFrom: job.id };
+}