@studious-lms/server 1.1.24 → 1.2.6

package/src/routers/notifications.ts

@@ -1,93 +1,43 @@
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
-import { prisma } from "../lib/prisma.js";
 import { z } from "zod";
+import {
+  listNotifications,
+  getNotification,
+  sendNotification,
+  sendToMultiple,
+  markAsRead,
+} from "../services/notification.js";
 
 export const notificationRouter = createTRPCRouter({
-    list: protectedProcedure.query(async ({ ctx }) => {
-        const notifications = await prisma.notification.findMany({
-            where: {
-                receiverId: ctx.user!.id,
-            },
-            orderBy: {
-                createdAt: "desc",
-            },
-            include: {
-                sender: {
-                    select: {
-                        username: true,
-                    },
-                },
-                receiver: {
-                    select: {
-                        username: true,
-                    },
-                },
-            },
-        });
+  list: protectedProcedure.query(({ ctx }) =>
+    listNotifications(ctx.user!.id)
+  ),
 
-        return notifications;
-    }),
-    get: protectedProcedure.input(z.object({
-        id: z.string(),
-    })).query(async ({ ctx, input }) => {
-        const { id } = input;
-        const notification = await prisma.notification.findUnique({
-            where: {
-                id,
-            },
-            include: {
-                sender: {
-                    select: {
-                        username: true,
-                    },
-                },
-                receiver: {
-                    select: {
-                        username: true,
-                    },
-                },
-            },
-        });
-        return notification;
-    }),
-    sendTo: protectedProcedure.input(z.object({
+  get: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .query(({ input }) => getNotification(input.id)),
+
+  sendTo: protectedProcedure
+    .input(
+      z.object({
         receiverId: z.string(),
         title: z.string(),
         content: z.string(),
-    })).mutation(async ({ ctx, input }) => {
-        const { receiverId, title, content } = input;
-        const notification = await prisma.notification.create({
-            data: {
-                receiverId,
-                title,
-                content,
-            },
-        });
-        return notification;
-    }),
-    sendToMultiple: protectedProcedure.input(z.object({
+      })
+    )
+    .mutation(({ input }) => sendNotification(input)),
+
+  sendToMultiple: protectedProcedure
+    .input(
+      z.object({
         receiverIds: z.array(z.string()),
         title: z.string(),
         content: z.string(),
-    })).mutation(async ({ ctx, input }) => {
-        const { receiverIds, title, content } = input;
-        const notifications = await prisma.notification.createMany({
-            data: receiverIds.map(receiverId => ({
-                receiverId,
-                title,
-                content,
-            })),
-        });
-        return notifications;
-    }),
-    markAsRead: protectedProcedure.input(z.object({
-        id: z.string(),
-    })).mutation(async ({ ctx, input }) => {
-        const { id } = input;
-        const notification = await prisma.notification.update({
-            where: { id },
-            data: { read: true },
-        });
-        return notification;
-    }),
-})
+      })
+    )
+    .mutation(({ input }) => sendToMultiple(input)),
+
+  markAsRead: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(({ input }) => markAsRead(input.id)),
+});

package/src/routers/section.ts

@@ -1,10 +1,21 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc.js";
-import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma.js";
+import {
+  createTRPCRouter,
+  protectedClassMemberProcedure,
+  protectedTeacherProcedure,
+} from "../trpc.js";
+import {
+  sectionExists,
+  createSectionRecord,
+  reorderSection,
+  updateSectionRecord,
+  reOrderSection,
+  deleteSectionRecord,
+} from "../services/section.js";
 
 const createSectionSchema = z.object({
   classId: z.string(),
+  id: z.string().optional(),
   name: z.string(),
   color: z.string().optional(),
 });
@@ -22,203 +33,50 @@ const deleteSectionSchema = z.object({
 });
 
 export const sectionRouter = createTRPCRouter({
-  create: protectedProcedure
-    .input(createSectionSchema)
-    .mutation(async ({ ctx, input }) => {
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      // Verify user is a teacher of the class
-      const classData = await prisma.class.findFirst({
-        where: {
-          id: input.classId,
-          teachers: {
-            some: {
-              id: ctx.user.id,
-            },
-          },
-        },
-      });
-
-      if (!classData) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Class not found or you are not a teacher",
-        });
-      }
-
-      const section = await prisma.section.create({
-        data: {
-          name: input.name,
-          order: 0,
-          class: {
-            connect: { id: input.classId },
-          },
-          ...(input.color && {
-            color: input.color,
-          }),
-        },
-      });
-
-      // find all root items in the class and reorder them
-      const sections = await prisma.section.findMany({
-        where: {
-          classId: input.classId,
-        },
-      });
-
-      const assignments = await prisma.assignment.findMany({
-        where: {
-          classId: input.classId,
-          sectionId: null,
-        },
-      });
-
-      const stack = [...sections, ...assignments].sort((a, b) => (a.order || 0) - (b.order || 0)).map((item, index) => ({
-        id: item.id,
-        order: index + 1,
-      })).map((item) => ({
-        where: { id: item.id },
-        data: { order: item.order },
-      }));
+  exists: protectedClassMemberProcedure
+    .input(z.object({ id: z.string() }))
+    .query(({ input }) => sectionExists(input.id)),
 
-      // Update sections and assignments with their new order
-      await Promise.all([
-        ...stack.filter(item => sections.some(s => s.id === item.where.id))
-          .map(({ where, data }) => 
-            prisma.section.update({ where, data })
-          ),
-        ...stack.filter(item => assignments.some(a => a.id === item.where.id))
-          .map(({ where, data }) => 
-            prisma.assignment.update({ where, data })
-          )
-      ]);
-
-      return section;
-    }),
-
-  update: protectedProcedure
+  create: protectedTeacherProcedure
+    .input(createSectionSchema)
+    .mutation(({ ctx, input }) =>
+      createSectionRecord(ctx.user!.id, input)
+    ),
+
+  reorder: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        movedId: z.string(),
+        position: z.enum(["start", "end", "before", "after"]),
+        targetId: z.string().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      reorderSection(ctx.user!.id, input)
+    ),
+
+  update: protectedTeacherProcedure
     .input(updateSectionSchema)
-    .mutation(async ({ ctx, input }) => {
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      // Verify user is a teacher of the class
-      const classData = await prisma.class.findFirst({
-        where: {
-          id: input.classId,
-          teachers: {
-            some: {
-              id: ctx.user.id,
-            },
-          },
-        },
-      });
-
-      if (!classData) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Class not found or you are not a teacher",
-        });
-      }
-
-      const section = await prisma.section.update({
-        where: { id: input.id },
-        data: {
-          name: input.name,
-          ...(input.color && {
-            color: input.color,
-          }),
-        },
-      });
-
-      return section;
-    }),
-
-  reOrder: protectedProcedure
-    .input(z.object({
-      id: z.string(),
-      classId: z.string(),
-      order: z.number(),
-    }))
-    .mutation(async ({ ctx, input }) => {
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      // Verify user is a teacher of the class
-      const classData = await prisma.class.findFirst({
-        where: {
-          id: input.classId,
-          teachers: {
-            some: {
-              id: ctx.user.id,
-            },
-          },
-        },
-      });
-
-      if (!classData) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Class not found or you are not a teacher",
-        });
-      }
-
-      await prisma.section.update({
-        where: { id: input.id },
-        data: {
-          order: input.order,
-        },
-      });
-
-      return { id: input.id };
-    }),
-
-  delete: protectedProcedure
+    .mutation(({ ctx, input }) =>
+      updateSectionRecord(ctx.user!.id, input)
+    ),
+
+  reOrder: protectedTeacherProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        classId: z.string(),
+        order: z.number(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      reOrderSection(ctx.user!.id, input)
+    ),
+
+  delete: protectedTeacherProcedure
     .input(deleteSectionSchema)
-    .mutation(async ({ ctx, input }) => {
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      // Verify user is a teacher of the class
-      const classData = await prisma.class.findFirst({
-        where: {
-          id: input.classId,
-          teachers: {
-            some: {
-              id: ctx.user.id,
-            },
-          },
-        },
-      });
-
-      if (!classData) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "Class not found or you are not a teacher",
-        });
-      }
-
-      await prisma.section.delete({
-        where: { id: input.id },
-      });
-
-      return { id: input.id };
-    }),
-}); 
+    .mutation(({ ctx, input }) =>
+      deleteSectionRecord(ctx.user!.id, input)
+    ),
+});