@studious-lms/server 1.1.26 → 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,325 +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,
-          }),
-        },
-      });
-
-      // Insert new section at top of unified list (sections + assignments) and normalize
-      const [sections, assignments] = await Promise.all([
-        prisma.section.findMany({
-          where: { classId: input.classId },
-          select: { id: true, order: true },
-        }),
-        prisma.assignment.findMany({
-          where: { classId: input.classId },
-          select: { id: true, order: true },
-        }),
-      ]);
-
-      const unified = [
-        ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' as const })),
-        ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' as const })),
-      ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
-
-      const withoutNew = unified.filter(item => !(item.id === section.id && item.type === 'section'));
-      const reindexed = [{ id: section.id, type: 'section' as const }, ...withoutNew.map(item => ({ id: item.id, type: item.type }))];
-
-      await Promise.all(
-        reindexed.map((item, index) => {
-          if (item.type === 'section') {
-            return prisma.section.update({ where: { id: item.id }, data: { order: index + 1 } });
-          } else {
-            return prisma.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
-          }
-        })
-      );
-
-      return section;
-    }),
-
-  reorder: protectedProcedure
-    .input(z.object({
-      classId: z.string(),
-      movedId: z.string(), // Section ID
-      // One of: place at start/end of unified list, or relative to targetId (can be section or assignment)
-      position: z.enum(['start', 'end', 'before', 'after']),
-      targetId: z.string().optional(), // Can be a section ID or assignment ID
-    }))
-    .mutation(async ({ ctx, input }) => {
-      if (!ctx.user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "User must be authenticated",
-        });
-      }
-
-      const { classId, movedId, position, targetId } = input;
-
-      const moved = await prisma.section.findFirst({
-        where: { id: movedId, classId },
-        select: { id: true, classId: true },
-      });
-
-      if (!moved) {
-        throw new TRPCError({ code: 'NOT_FOUND', message: 'Section not found' });
-      }
-
-      if ((position === 'before' || position === 'after') && !targetId) {
-        throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId required for before/after' });
-      }
-
-      const result = await prisma.$transaction(async (tx) => {
-        const [sections, assignments] = await Promise.all([
-          tx.section.findMany({
-            where: { classId },
-            select: { id: true, order: true },
-          }),
-          tx.assignment.findMany({
-            where: { classId },
-            select: { id: true, order: true },
-          }),
-        ]);
-
-        const unified = [
-          ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' as const })),
-          ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' as const })),
-        ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
-
-        const movedIdx = unified.findIndex(item => item.id === movedId && item.type === 'section');
-        if (movedIdx === -1) {
-          throw new TRPCError({ code: 'NOT_FOUND', message: 'Section not found in unified list' });
-        }
-
-        const withoutMoved = unified.filter(item => !(item.id === movedId && item.type === 'section'));
-
-        let next: Array<{ id: string; type: 'section' | 'assignment' }> = [];
-
-        if (position === 'start') {
-          next = [{ id: movedId, type: 'section' }, ...withoutMoved.map(item => ({ id: item.id, type: item.type }))];
-        } else if (position === 'end') {
-          next = [...withoutMoved.map(item => ({ id: item.id, type: item.type })), { id: movedId, type: 'section' }];
-        } else {
-          const targetIdx = withoutMoved.findIndex(item => item.id === targetId);
-          if (targetIdx === -1) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'targetId not found in unified list' });
-          }
-          if (position === 'before') {
-            next = [
-              ...withoutMoved.slice(0, targetIdx).map(item => ({ id: item.id, type: item.type })),
-              { id: movedId, type: 'section' },
-              ...withoutMoved.slice(targetIdx).map(item => ({ id: item.id, type: item.type })),
-            ];
-          } else {
-            next = [
-              ...withoutMoved.slice(0, targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
-              { id: movedId, type: 'section' },
-              ...withoutMoved.slice(targetIdx + 1).map(item => ({ id: item.id, type: item.type })),
-            ];
-          }
-        }
-
-        // Normalize to 1..n
-        await Promise.all(
-          next.map((item, index) => {
-            if (item.type === 'section') {
-              return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
-            } else {
-              return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
-            }
-          })
-        );
+  exists: protectedClassMemberProcedure
+    .input(z.object({ id: z.string() }))
+    .query(({ input }) => sectionExists(input.id)),
 
-        return tx.section.findUnique({ where: { id: movedId } });
-      });
-
-      return result;
-    }),
-
-  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",
-        });
-      }
-
-      // Update order and normalize unified list
-      await prisma.$transaction(async (tx) => {
-        await tx.section.update({
-          where: { id: input.id },
-          data: { order: input.order },
-        });
-
-        // Normalize entire unified list
-        const [sections, assignments] = await Promise.all([
-          tx.section.findMany({
-            where: { classId: input.classId },
-            select: { id: true, order: true },
-          }),
-          tx.assignment.findMany({
-            where: { classId: input.classId },
-            select: { id: true, order: true },
-          }),
-        ]);
-
-        const unified = [
-          ...sections.map(s => ({ id: s.id, order: s.order, type: 'section' as const })),
-          ...assignments.map(a => ({ id: a.id, order: a.order, type: 'assignment' as const })),
-        ].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
-
-        await Promise.all(
-          unified.map((item, index) => {
-            if (item.type === 'section') {
-              return tx.section.update({ where: { id: item.id }, data: { order: index + 1 } });
-            } else {
-              return tx.assignment.update({ where: { id: item.id }, data: { order: index + 1 } });
-            }
-          })
-        );
-      });
-
-      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)
+    ),
+});