@studious-lms/server 1.7.0 → 1.9.0

package/src/models/comment.ts

@@ -52,10 +52,6 @@ const commentClassAuthSelect = {
   students: { select: { id: true } },
   school: {
     select: {
-      users: {
-        where: { role: "ADMIN" as const },
-        select: { id: true },
-      },
       memberships: {
         where: {
           role: "ADMIN" as const,

package/src/models/department.ts

@@ -0,0 +1,159 @@
+/**
+ * Department model — department CRUD, members, and template artefacts.
+ *
+ * Departments scope rubric/boundary templates and tags inside an institution.
+ * They are an admin-managed taxonomy; teachers/students can be members of
+ * many departments.
+ */
+import { prisma } from "../lib/prisma.js";
+
+const departmentSelect = {
+  id: true,
+  schoolId: true,
+  name: true,
+  description: true,
+  color: true,
+  createdAt: true,
+  updatedAt: true,
+} as const;
+
+const memberSelect = {
+  id: true,
+  username: true,
+  email: true,
+  profile: {
+    select: {
+      displayName: true,
+      profilePicture: true,
+      profilePictureThumbnail: true,
+    },
+  },
+} as const;
+
+export function listDepartmentsForSchool(schoolId: string) {
+  return prisma.department.findMany({
+    where: { schoolId },
+    orderBy: { name: "asc" },
+    select: {
+      ...departmentSelect,
+      _count: {
+        select: {
+          members: true,
+          classes: true,
+          tags: true,
+          rubricTemplates: true,
+          boundaryTemplates: true,
+        },
+      },
+    },
+  });
+}
+
+export function listDepartmentsForUser(userId: string, schoolId: string) {
+  return prisma.department.findMany({
+    where: {
+      schoolId,
+      members: { some: { id: userId } },
+    },
+    orderBy: { name: "asc" },
+    select: departmentSelect,
+  });
+}
+
+export function getDepartment(departmentId: string) {
+  return prisma.department.findUnique({
+    where: { id: departmentId },
+    select: {
+      ...departmentSelect,
+      members: { select: memberSelect },
+      tags: {
+        select: { id: true, name: true, color: true },
+      },
+      rubricTemplates: {
+        select: { id: true, name: true, structured: true },
+      },
+      boundaryTemplates: {
+        select: { id: true, name: true, structured: true },
+      },
+      classes: {
+        select: {
+          id: true,
+          name: true,
+          subject: true,
+          section: true,
+          color: true,
+        },
+      },
+    },
+  });
+}
+
+export function createDepartment(data: {
+  schoolId: string;
+  name: string;
+  description?: string;
+  color?: string;
+}) {
+  return prisma.department.create({
+    data: {
+      schoolId: data.schoolId,
+      name: data.name,
+      description: data.description,
+      color: data.color,
+    },
+    select: departmentSelect,
+  });
+}
+
+export function updateDepartment(
+  departmentId: string,
+  data: { name?: string; description?: string | null; color?: string }
+) {
+  return prisma.department.update({
+    where: { id: departmentId },
+    data,
+    select: departmentSelect,
+  });
+}
+
+export function deleteDepartment(departmentId: string) {
+  return prisma.department.delete({
+    where: { id: departmentId },
+  });
+}
+
+export function addDepartmentMembers(
+  departmentId: string,
+  userIds: string[]
+) {
+  return prisma.department.update({
+    where: { id: departmentId },
+    data: {
+      members: { connect: userIds.map((id) => ({ id })) },
+    },
+    select: { id: true },
+  });
+}
+
+export function removeDepartmentMember(
+  departmentId: string,
+  userId: string
+) {
+  return prisma.department.update({
+    where: { id: departmentId },
+    data: {
+      members: { disconnect: { id: userId } },
+    },
+    select: { id: true },
+  });
+}
+
+export function findDepartmentMembership(
+  departmentId: string,
+  userId: string
+) {
+  return prisma.department.findFirst({
+    where: { id: departmentId, members: { some: { id: userId } } },
+    select: { id: true },
+  });
+}

package/src/models/event.ts

@@ -11,7 +11,6 @@ const eventGetInclude = {
       school: {
         include: {
           users: {
-            where: { role: "ADMIN" as const },
             select: { id: true },
           },
           memberships: {
@@ -134,7 +133,6 @@ export function findEventWithClass(eventId: string) {
           school: {
             include: {
               users: {
-                where: { role: "ADMIN" as const },
                 select: { id: true },
               },
               memberships: {
@@ -163,7 +161,6 @@ export function findAssignmentWithClass(assignmentId: string) {
           school: {
             include: {
               users: {
-                where: { role: "ADMIN" as const },
                 select: { id: true },
               },
               memberships: {

package/src/models/file.ts

@@ -8,10 +8,6 @@ const classFileAccessInclude = {
   teachers: true,
   school: {
     include: {
-      users: {
-        where: { role: "ADMIN" as const },
-        select: { id: true },
-      },
       memberships: {
         where: {
           role: "ADMIN" as const,
@@ -41,24 +37,7 @@ export function findFileById(fileId: string) {
           assignment: {
             include: {
               class: {
-                include: {
-                  teachers: true,
-                  school: {
-                    include: {
-                      users: {
-                        where: { role: "ADMIN" as const },
-                        select: { id: true },
-                      },
-                      memberships: {
-                        where: {
-                          role: "ADMIN" as const,
-                          status: "ACTIVE" as const,
-                        },
-                        select: { userId: true },
-                      },
-                    },
-                  },
-                },
+                include: classFileAccessInclude,
               },
             },
           },
@@ -70,24 +49,7 @@ export function findFileById(fileId: string) {
           assignment: {
             include: {
               class: {
-                include: {
-                  teachers: true,
-                  school: {
-                    include: {
-                      users: {
-                        where: { role: "ADMIN" as const },
-                        select: { id: true },
-                      },
-                      memberships: {
-                        where: {
-                          role: "ADMIN" as const,
-                          status: "ACTIVE" as const,
-                        },
-                        select: { userId: true },
-                      },
-                    },
-                  },
-                },
+                include: classFileAccessInclude,
               },
             },
           },

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,9 @@ 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";
+import { permissionsRouter } from "./permissions.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -47,6 +50,9 @@ export const appRouter = createTRPCRouter({
   studentProgress: studentProgressRouter,
   search: searchRouter,
   school: schoolRouter,
+  department: departmentRouter,
+  tag: tagRouter,
+  permissions: permissionsRouter,
 });
 
 // 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 }) =>