@studious-lms/server 1.7.0 → 1.8.0

package/src/models/message.ts

@@ -1,15 +1,29 @@
 /**
  * Message model – messages, attachments, mentions, unread counts.
  */
+import type { Prisma } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 
+/**
+ * Canonical shape for File rows surfaced as message attachments.
+ * Use this everywhere a message (list, send, update, suggestion broadcast)
+ * exposes attached files so the wire shape stays in sync.
+ */
+export const messageFileSelect = {
+  id: true,
+  name: true,
+  type: true,
+  size: true,
+  path: true,
+  uploadedAt: true,
+  uploadStatus: true,
+  thumbnailId: true,
+  thumbnail: { select: { id: true, path: true } },
+} as const satisfies Prisma.FileSelect;
+
 const messageInclude = {
   attachments: {
-    select: {
-      id: true,
-      name: true,
-      type: true,
-    },
+    select: messageFileSelect,
   },
   sender: {
     select: {

package/src/models/school.ts

@@ -52,8 +52,10 @@ export function listUserSchoolMemberships(userId: string) {
         select: {
           id: true,
           name: true,
+          description: true,
           subdomain: true,
           logoId: true,
+          logo: { select: { id: true, path: true, type: true } },
           createdAt: true,
           updatedAt: true,
         },
@@ -96,14 +98,38 @@ export function getSchoolById(schoolId: string) {
     select: {
       id: true,
       name: true,
+      description: true,
       subdomain: true,
       logoId: true,
+      logo: { select: { id: true, name: true, type: true, path: true } },
       createdAt: true,
       updatedAt: true,
     },
   });
 }
 
+export function updateSchoolRecord(
+  schoolId: string,
+  data: {
+    name?: string;
+    description?: string | null;
+    subdomain?: string | null;
+    logoId?: string | null;
+  }
+) {
+  return prisma.school.update({
+    where: { id: schoolId },
+    data,
+    select: {
+      id: true,
+      name: true,
+      description: true,
+      subdomain: true,
+      logoId: true,
+    },
+  });
+}
+
 export function getSchoolOverview(schoolId: string) {
   return prisma.school.findUnique({
     where: { id: schoolId },

package/src/models/tag.ts

@@ -0,0 +1,140 @@
+/**
+ * Tag model — institution-scoped tags applicable to users, classes, rubrics,
+ * and grading boundaries. Optionally associated with a department.
+ */
+import { prisma } from "../lib/prisma.js";
+
+const tagSelect = {
+  id: true,
+  schoolId: true,
+  departmentId: true,
+  name: true,
+  color: true,
+  createdAt: true,
+  updatedAt: true,
+} as const;
+
+export type TagTarget = "USER" | "CLASS" | "RUBRIC" | "BOUNDARY";
+
+export function listTagsForSchool(
+  schoolId: string,
+  options?: { departmentId?: string | null }
+) {
+  return prisma.tag.findMany({
+    where: {
+      schoolId,
+      ...(options?.departmentId === null
+        ? { departmentId: null }
+        : options?.departmentId
+          ? { departmentId: options.departmentId }
+          : {}),
+    },
+    orderBy: [{ name: "asc" }],
+    select: tagSelect,
+  });
+}
+
+export function getTag(tagId: string) {
+  return prisma.tag.findUnique({
+    where: { id: tagId },
+    select: tagSelect,
+  });
+}
+
+export function createTag(data: {
+  schoolId: string;
+  departmentId?: string | null;
+  name: string;
+  color?: string;
+}) {
+  return prisma.tag.create({
+    data: {
+      schoolId: data.schoolId,
+      departmentId: data.departmentId ?? null,
+      name: data.name,
+      color: data.color ?? "#3B82F6",
+    },
+    select: tagSelect,
+  });
+}
+
+export function updateTag(
+  tagId: string,
+  data: { name?: string; color?: string; departmentId?: string | null }
+) {
+  return prisma.tag.update({
+    where: { id: tagId },
+    data,
+    select: tagSelect,
+  });
+}
+
+export function deleteTag(tagId: string) {
+  return prisma.tag.delete({ where: { id: tagId } });
+}
+
+const targetRelation: Record<TagTarget, "users" | "classes" | "rubrics" | "boundaries"> = {
+  USER: "users",
+  CLASS: "classes",
+  RUBRIC: "rubrics",
+  BOUNDARY: "boundaries",
+};
+
+export function attachTagToTarget(params: {
+  tagId: string;
+  target: TagTarget;
+  targetId: string;
+}) {
+  const relation = targetRelation[params.target];
+  return prisma.tag.update({
+    where: { id: params.tagId },
+    data: {
+      [relation]: { connect: { id: params.targetId } },
+    },
+    select: { id: true },
+  });
+}
+
+export function detachTagFromTarget(params: {
+  tagId: string;
+  target: TagTarget;
+  targetId: string;
+}) {
+  const relation = targetRelation[params.target];
+  return prisma.tag.update({
+    where: { id: params.tagId },
+    data: {
+      [relation]: { disconnect: { id: params.targetId } },
+    },
+    select: { id: true },
+  });
+}
+
+export function listTagsAttachedTo(target: TagTarget, targetId: string) {
+  switch (target) {
+    case "USER":
+      return prisma.tag.findMany({
+        where: { users: { some: { id: targetId } } },
+        select: tagSelect,
+        orderBy: { name: "asc" },
+      });
+    case "CLASS":
+      return prisma.tag.findMany({
+        where: { classes: { some: { id: targetId } } },
+        select: tagSelect,
+        orderBy: { name: "asc" },
+      });
+    case "RUBRIC":
+      return prisma.tag.findMany({
+        where: { rubrics: { some: { id: targetId } } },
+        select: tagSelect,
+        orderBy: { name: "asc" },
+      });
+    case "BOUNDARY":
+      return prisma.tag.findMany({
+        where: { boundaries: { some: { id: targetId } } },
+        select: tagSelect,
+        orderBy: { name: "asc" },
+      });
+  }
+}

package/src/routers/_app.ts

@@ -23,6 +23,8 @@ import { commentRouter } from "./comment.js";
 import { studentProgressRouter } from "./studentProgress.js";
 import { searchRouter } from "./search.js";
 import { schoolRouter } from "./school.js";
+import { departmentRouter } from "./department.js";
+import { tagRouter } from "./tag.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -47,6 +49,8 @@ export const appRouter = createTRPCRouter({
   studentProgress: studentProgressRouter,
   search: searchRouter,
   school: schoolRouter,
+  department: departmentRouter,
+  tag: tagRouter,
 });
 
 // Export type router type definition

package/src/routers/announcement.ts

@@ -342,9 +342,7 @@ export const announcementRouter = createTRPCRouter({
                                     school: {
                                         include: {
                                             users: {
-                                                where: {
-                                                    role: "ADMIN",
-                                                },
+                                                select: { id: true },
                                             },
                                             memberships: {
                                                 where: {

package/src/routers/assignment.ts

@@ -722,7 +722,6 @@ export const assignmentRouter = createTRPCRouter({
                   school: {
                     include: {
                       users: {
-                        where: { role: "ADMIN" },
                         select: { id: true },
                       },
                       memberships: {

package/src/routers/class.ts

@@ -58,6 +58,8 @@ export const classRouter = createTRPCRouter({
         name: z.string().optional(),
         section: z.string().optional(),
         subject: z.string().optional(),
+        color: z.string().optional(),
+        departmentId: z.string().nullable().optional(),
       })
     )
     .mutation(({ input }) => {
@@ -75,6 +77,7 @@ export const classRouter = createTRPCRouter({
         subject: z.string(),
         color: z.string().optional(),
         schoolId: z.string().optional(),
+        departmentId: z.string().optional(),
       })
     )
     .mutation(({ ctx, input }) =>

package/src/routers/department.ts

@@ -0,0 +1,174 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import {
+  addMembersToDepartment,
+  applyBoundaryTemplate,
+  applyRubricTemplate,
+  createBoundaryTemplate,
+  createDepartmentRecord,
+  createRubricTemplate,
+  deleteBoundaryTemplate,
+  deleteDepartmentRecord,
+  deleteRubricTemplate,
+  getDepartmentDetails,
+  listDepartments,
+  listMyDepartments,
+  removeMemberFromDepartment,
+  setClassDepartment,
+  updateBoundaryTemplate,
+  updateDepartmentRecord,
+  updateRubricTemplate,
+} from "../services/department.js";
+
+export const departmentRouter = createTRPCRouter({
+  list: protectedProcedure
+    .input(z.object({ schoolId: z.string() }))
+    .query(({ ctx, input }) => listDepartments(ctx.user!.id, input.schoolId)),
+
+  listMine: protectedProcedure
+    .input(z.object({ schoolId: z.string() }))
+    .query(({ ctx, input }) =>
+      listMyDepartments(ctx.user!.id, input.schoolId)
+    ),
+
+  get: protectedProcedure
+    .input(z.object({ departmentId: z.string() }))
+    .query(({ ctx, input }) =>
+      getDepartmentDetails(ctx.user!.id, input.departmentId)
+    ),
+
+  create: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        name: z.string().min(1),
+        description: z.string().optional(),
+        color: z.string().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      createDepartmentRecord(ctx.user!.id, input)
+    ),
+
+  update: protectedProcedure
+    .input(
+      z.object({
+        departmentId: z.string(),
+        name: z.string().min(1).optional(),
+        description: z.string().nullable().optional(),
+        color: z.string().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      updateDepartmentRecord(ctx.user!.id, input)
+    ),
+
+  delete: protectedProcedure
+    .input(z.object({ departmentId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      deleteDepartmentRecord(ctx.user!.id, input.departmentId)
+    ),
+
+  addMembers: protectedProcedure
+    .input(
+      z.object({
+        departmentId: z.string(),
+        userIds: z.array(z.string()),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      addMembersToDepartment(ctx.user!.id, input)
+    ),
+
+  removeMember: protectedProcedure
+    .input(z.object({ departmentId: z.string(), memberId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      removeMemberFromDepartment(ctx.user!.id, input)
+    ),
+
+  setClassDepartment: protectedProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        departmentId: z.string().nullable(),
+      })
+    )
+    .mutation(({ ctx, input }) => setClassDepartment(ctx.user!.id, input)),
+
+  /** Template authoring. */
+  createRubricTemplate: protectedProcedure
+    .input(
+      z.object({
+        departmentId: z.string(),
+        name: z.string(),
+        structured: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      createRubricTemplate(ctx.user!.id, input)
+    ),
+
+  updateRubricTemplate: protectedProcedure
+    .input(
+      z.object({
+        templateId: z.string(),
+        name: z.string().optional(),
+        structured: z.string().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      updateRubricTemplate(ctx.user!.id, input)
+    ),
+
+  deleteRubricTemplate: protectedProcedure
+    .input(z.object({ templateId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      deleteRubricTemplate(ctx.user!.id, input.templateId)
+    ),
+
+  createBoundaryTemplate: protectedProcedure
+    .input(
+      z.object({
+        departmentId: z.string(),
+        name: z.string(),
+        structured: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      createBoundaryTemplate(ctx.user!.id, input)
+    ),
+
+  updateBoundaryTemplate: protectedProcedure
+    .input(
+      z.object({
+        templateId: z.string(),
+        name: z.string().optional(),
+        structured: z.string().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      updateBoundaryTemplate(ctx.user!.id, input)
+    ),
+
+  deleteBoundaryTemplate: protectedProcedure
+    .input(z.object({ templateId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      deleteBoundaryTemplate(ctx.user!.id, input.templateId)
+    ),
+
+  applyRubricTemplate: protectedProcedure
+    .input(
+      z.object({ classId: z.string(), templateId: z.string() })
+    )
+    .mutation(({ ctx, input }) =>
+      applyRubricTemplate(ctx.user!.id, input)
+    ),
+
+  applyBoundaryTemplate: protectedProcedure
+    .input(
+      z.object({ classId: z.string(), templateId: z.string() })
+    )
+    .mutation(({ ctx, input }) =>
+      applyBoundaryTemplate(ctx.user!.id, input)
+    ),
+});

package/src/routers/file.ts

@@ -1,16 +1,20 @@
 import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import {
-  createTRPCRouter,
-  protectedProcedure,
-  protectedTeacherProcedure,
-} from "../trpc.js";
-import {
+  deleteFileGeneric,
   getFileSignedUrl,
-  moveFile,
-  renameFile,
-  deleteFileRecord,
+  moveFileScoped,
+  renameFileScoped,
 } from "../services/file.js";
 
+/**
+ * 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 /
+ * institution) both run through the same endpoints.
+ *
+ * Permissions are derived from the file's parent folder scope, so callers
+ * never need to send `classId` / `scope` — just the file id.
+ */
 export const fileRouter = createTRPCRouter({
   getSignedUrl: protectedProcedure
     .input(z.object({ fileId: z.string() }))
@@ -18,38 +22,37 @@ export const fileRouter = createTRPCRouter({
       getFileSignedUrl(ctx.user!.id, input.fileId)
     ),
 
-  move: protectedTeacherProcedure
+  move: protectedProcedure
     .input(
       z.object({
         fileId: z.string(),
         targetFolderId: z.string(),
-        classId: z.string(),
       })
     )
-    .mutation(({ input }) =>
-      moveFile(input.fileId, input.targetFolderId)
+    .mutation(({ ctx, input }) =>
+      moveFileScoped(ctx.user!.id, {
+        fileId: input.fileId,
+        targetFolderId: input.targetFolderId,
+      })
     ),
 
-  rename: protectedTeacherProcedure
+  rename: protectedProcedure
     .input(
       z.object({
         fileId: z.string(),
-        newName: z.string(),
-        classId: z.string(),
+        newName: z.string().min(1),
       })
     )
-    .mutation(({ input }) =>
-      renameFile(input.fileId, input.newName)
+    .mutation(({ ctx, input }) =>
+      renameFileScoped(ctx.user!.id, {
+        fileId: input.fileId,
+        newName: input.newName,
+      })
     ),
 
-  delete: protectedTeacherProcedure
-    .input(
-      z.object({
-        fileId: z.string(),
-        classId: z.string(),
-      })
-    )
-    .mutation(({ input }) =>
-      deleteFileRecord(input.fileId, input.classId)
+  delete: protectedProcedure
+    .input(z.object({ fileId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      deleteFileGeneric(ctx.user!.id, input.fileId)
     ),
 });